blob: 9f0b943c62c7955664d2ab3ffafba0d1b06eb59c [file] [log] [blame]
// WARNING: This file is machine generated by fidlgen.
#pragma once
#include <lib/fidl/internal.h>
#include <lib/fidl/cpp/vector_view.h>
#include <lib/fidl/cpp/string_view.h>
#include <lib/fidl/llcpp/array.h>
#include <lib/fidl/llcpp/coding.h>
#include <lib/fidl/llcpp/sync_call.h>
#include <lib/fidl/llcpp/traits.h>
#include <lib/fidl/llcpp/transaction.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 Controller_UpdatePowerStateMapping_Response;
struct Controller_UpdatePowerStateMapping_Result;
class Controller;
extern "C" const fidl_type_t fuchsia_device_NameProvider_GetDeviceName_ResponseTable;
struct NameProvider_GetDeviceName_Response {
static constexpr const fidl_type_t* Type = &fuchsia_device_NameProvider_GetDeviceName_ResponseTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 16;
[[maybe_unused]]
static constexpr uint32_t MaxOutOfLine = 4294967295;
::fidl::StringView name = {};
};
extern "C" const fidl_type_t fuchsia_device_NameProvider_GetDeviceName_ResultTable;
struct NameProvider_GetDeviceName_Result {
enum class Tag : fidl_union_tag_t {
kResponse = 0,
kErr = 1,
Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
};
NameProvider_GetDeviceName_Result();
~NameProvider_GetDeviceName_Result();
NameProvider_GetDeviceName_Result(NameProvider_GetDeviceName_Result&& other) {
tag_ = Tag::Invalid;
if (this != &other) {
MoveImpl_(std::move(other));
}
}
NameProvider_GetDeviceName_Result& operator=(NameProvider_GetDeviceName_Result&& other) {
if (this != &other) {
MoveImpl_(std::move(other));
}
return *this;
}
bool has_invalid_tag() const { return tag_ == Tag::Invalid; }
bool is_response() const { return tag_ == Tag::kResponse; }
NameProvider_GetDeviceName_Response& mutable_response();
template <typename T>
std::enable_if_t<std::is_convertible<T, NameProvider_GetDeviceName_Response>::value && std::is_copy_assignable<T>::value>
set_response(const T& v) {
mutable_response() = v;
}
template <typename T>
std::enable_if_t<std::is_convertible<T, NameProvider_GetDeviceName_Response>::value && std::is_move_assignable<T>::value>
set_response(T&& v) {
mutable_response() = std::move(v);
}
NameProvider_GetDeviceName_Response const & response() const { return response_; }
bool is_err() const { return tag_ == Tag::kErr; }
int32_t& mutable_err();
template <typename T>
std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
set_err(const T& v) {
mutable_err() = v;
}
template <typename T>
std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
set_err(T&& v) {
mutable_err() = std::move(v);
}
int32_t const & err() const { return err_; }
Tag which() const { return tag_; }
static constexpr const fidl_type_t* Type = &fuchsia_device_NameProvider_GetDeviceName_ResultTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 24;
[[maybe_unused]]
static constexpr uint32_t MaxOutOfLine = 4294967295;
private:
void Destroy();
void MoveImpl_(NameProvider_GetDeviceName_Result&& other);
static void SizeAndOffsetAssertionHelper();
Tag tag_;
union {
NameProvider_GetDeviceName_Response response_;
int32_t err_;
};
};
extern "C" const fidl_type_t 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;
NameProvider_GetDeviceName_Result result;
static constexpr const fidl_type_t* Type = &fuchsia_device_NameProviderGetDeviceNameResponseTable;
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 ::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 16 bytes of request buffer on the stack. Response is heap-allocated.
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 16 bytes of request buffer on the stack. Response is heap-allocated.
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(NameProvider_GetDeviceName_Result result);
void Reply(::fidl::BytePart _buffer, NameProvider_GetDeviceName_Result result);
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);
}
};
constexpr uint32_t MIN_DEVICE_POWER_STATES = 2u;
// 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 performant states.
constexpr uint32_t MAX_DEVICE_POWER_STATES = 5u;
// 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 fuchsia_device_SystemPowerStateInfoTable;
struct SystemPowerStateInfo {
static constexpr const fidl_type_t* Type = &fuchsia_device_SystemPowerStateInfoTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 8;
[[maybe_unused]]
static constexpr uint32_t MaxOutOfLine = 0;
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.
DevicePowerState dev_state = {};
};
extern "C" const fidl_type_t fuchsia_device_Controller_GetPowerStateMapping_ResponseTable;
struct Controller_GetPowerStateMapping_Response {
static constexpr const fidl_type_t* Type = &fuchsia_device_Controller_GetPowerStateMapping_ResponseTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 48;
[[maybe_unused]]
static constexpr uint32_t MaxOutOfLine = 0;
::fidl::Array<SystemPowerStateInfo, 6> mapping = {};
};
extern "C" const fidl_type_t fuchsia_device_Controller_GetPowerStateMapping_ResultTable;
struct Controller_GetPowerStateMapping_Result {
enum class Tag : fidl_union_tag_t {
kResponse = 0,
kErr = 1,
Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
};
Controller_GetPowerStateMapping_Result();
~Controller_GetPowerStateMapping_Result();
Controller_GetPowerStateMapping_Result(Controller_GetPowerStateMapping_Result&& other) {
tag_ = Tag::Invalid;
if (this != &other) {
MoveImpl_(std::move(other));
}
}
Controller_GetPowerStateMapping_Result& operator=(Controller_GetPowerStateMapping_Result&& other) {
if (this != &other) {
MoveImpl_(std::move(other));
}
return *this;
}
bool has_invalid_tag() const { return tag_ == Tag::Invalid; }
bool is_response() const { return tag_ == Tag::kResponse; }
Controller_GetPowerStateMapping_Response& mutable_response();
template <typename T>
std::enable_if_t<std::is_convertible<T, Controller_GetPowerStateMapping_Response>::value && std::is_copy_assignable<T>::value>
set_response(const T& v) {
mutable_response() = v;
}
template <typename T>
std::enable_if_t<std::is_convertible<T, Controller_GetPowerStateMapping_Response>::value && std::is_move_assignable<T>::value>
set_response(T&& v) {
mutable_response() = std::move(v);
}
Controller_GetPowerStateMapping_Response const & response() const { return response_; }
bool is_err() const { return tag_ == Tag::kErr; }
int32_t& mutable_err();
template <typename T>
std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
set_err(const T& v) {
mutable_err() = v;
}
template <typename T>
std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
set_err(T&& v) {
mutable_err() = std::move(v);
}
int32_t const & err() const { return err_; }
Tag which() const { return tag_; }
static constexpr const fidl_type_t* Type = &fuchsia_device_Controller_GetPowerStateMapping_ResultTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 52;
[[maybe_unused]]
static constexpr uint32_t MaxOutOfLine = 0;
private:
void Destroy();
void MoveImpl_(Controller_GetPowerStateMapping_Result&& other);
static void SizeAndOffsetAssertionHelper();
Tag tag_;
union {
Controller_GetPowerStateMapping_Response response_;
int32_t err_;
};
};
extern "C" const fidl_type_t fuchsia_device_DevicePowerStateInfoTable;
struct DevicePowerStateInfo {
static constexpr const fidl_type_t* Type = &fuchsia_device_DevicePowerStateInfoTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 24;
[[maybe_unused]]
static constexpr uint32_t MaxOutOfLine = 0;
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 fuchsia_device_Controller_GetDevicePowerCaps_ResponseTable;
struct Controller_GetDevicePowerCaps_Response {
static constexpr const fidl_type_t* Type = &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;
::fidl::Array<DevicePowerStateInfo, 5> dpstates = {};
};
extern "C" const fidl_type_t fuchsia_device_Controller_GetDevicePowerCaps_ResultTable;
struct Controller_GetDevicePowerCaps_Result {
enum class Tag : fidl_union_tag_t {
kResponse = 0,
kErr = 1,
Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
};
Controller_GetDevicePowerCaps_Result();
~Controller_GetDevicePowerCaps_Result();
Controller_GetDevicePowerCaps_Result(Controller_GetDevicePowerCaps_Result&& other) {
tag_ = Tag::Invalid;
if (this != &other) {
MoveImpl_(std::move(other));
}
}
Controller_GetDevicePowerCaps_Result& operator=(Controller_GetDevicePowerCaps_Result&& other) {
if (this != &other) {
MoveImpl_(std::move(other));
}
return *this;
}
bool has_invalid_tag() const { return tag_ == Tag::Invalid; }
bool is_response() const { return tag_ == Tag::kResponse; }
Controller_GetDevicePowerCaps_Response& mutable_response();
template <typename T>
std::enable_if_t<std::is_convertible<T, Controller_GetDevicePowerCaps_Response>::value && std::is_copy_assignable<T>::value>
set_response(const T& v) {
mutable_response() = v;
}
template <typename T>
std::enable_if_t<std::is_convertible<T, Controller_GetDevicePowerCaps_Response>::value && std::is_move_assignable<T>::value>
set_response(T&& v) {
mutable_response() = std::move(v);
}
Controller_GetDevicePowerCaps_Response const & response() const { return response_; }
bool is_err() const { return tag_ == Tag::kErr; }
int32_t& mutable_err();
template <typename T>
std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
set_err(const T& v) {
mutable_err() = v;
}
template <typename T>
std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
set_err(T&& v) {
mutable_err() = std::move(v);
}
int32_t const & err() const { return err_; }
Tag which() const { return tag_; }
static constexpr const fidl_type_t* Type = &fuchsia_device_Controller_GetDevicePowerCaps_ResultTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 128;
[[maybe_unused]]
static constexpr uint32_t MaxOutOfLine = 0;
private:
void Destroy();
void MoveImpl_(Controller_GetDevicePowerCaps_Result&& other);
static void SizeAndOffsetAssertionHelper();
Tag tag_;
union {
Controller_GetDevicePowerCaps_Response response_;
int32_t err_;
};
};
struct Controller_Resume_Response {
static constexpr const fidl_type_t* Type = nullptr;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 1;
[[maybe_unused]]
static constexpr uint32_t MaxOutOfLine = 0;
DevicePowerState out_state = {};
};
extern "C" const fidl_type_t fuchsia_device_Controller_Resume_ResultTable;
struct Controller_Resume_Result {
enum class Tag : fidl_union_tag_t {
kResponse = 0,
kErr = 1,
Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
};
Controller_Resume_Result();
~Controller_Resume_Result();
Controller_Resume_Result(Controller_Resume_Result&& other) {
tag_ = Tag::Invalid;
if (this != &other) {
MoveImpl_(std::move(other));
}
}
Controller_Resume_Result& operator=(Controller_Resume_Result&& other) {
if (this != &other) {
MoveImpl_(std::move(other));
}
return *this;
}
bool has_invalid_tag() const { return tag_ == Tag::Invalid; }
bool is_response() const { return tag_ == Tag::kResponse; }
Controller_Resume_Response& mutable_response();
template <typename T>
std::enable_if_t<std::is_convertible<T, Controller_Resume_Response>::value && std::is_copy_assignable<T>::value>
set_response(const T& v) {
mutable_response() = v;
}
template <typename T>
std::enable_if_t<std::is_convertible<T, Controller_Resume_Response>::value && std::is_move_assignable<T>::value>
set_response(T&& v) {
mutable_response() = std::move(v);
}
Controller_Resume_Response const & response() const { return response_; }
bool is_err() const { return tag_ == Tag::kErr; }
int32_t& mutable_err();
template <typename T>
std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
set_err(const T& v) {
mutable_err() = v;
}
template <typename T>
std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
set_err(T&& v) {
mutable_err() = std::move(v);
}
int32_t const & err() const { return err_; }
Tag which() const { return tag_; }
static constexpr const fidl_type_t* Type = &fuchsia_device_Controller_Resume_ResultTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 8;
[[maybe_unused]]
static constexpr uint32_t MaxOutOfLine = 0;
private:
void Destroy();
void MoveImpl_(Controller_Resume_Result&& other);
static void SizeAndOffsetAssertionHelper();
Tag tag_;
union {
Controller_Resume_Response response_;
int32_t err_;
};
};
// 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;
extern const char DEFAULT_DEVICE_NAME[];
struct Controller_UpdatePowerStateMapping_Response {
static constexpr const fidl_type_t* Type = nullptr;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 1;
[[maybe_unused]]
static constexpr uint32_t MaxOutOfLine = 0;
uint8_t __reserved = {};
};
extern "C" const fidl_type_t fuchsia_device_Controller_UpdatePowerStateMapping_ResultTable;
struct Controller_UpdatePowerStateMapping_Result {
enum class Tag : fidl_union_tag_t {
kResponse = 0,
kErr = 1,
Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
};
Controller_UpdatePowerStateMapping_Result();
~Controller_UpdatePowerStateMapping_Result();
Controller_UpdatePowerStateMapping_Result(Controller_UpdatePowerStateMapping_Result&& other) {
tag_ = Tag::Invalid;
if (this != &other) {
MoveImpl_(std::move(other));
}
}
Controller_UpdatePowerStateMapping_Result& operator=(Controller_UpdatePowerStateMapping_Result&& other) {
if (this != &other) {
MoveImpl_(std::move(other));
}
return *this;
}
bool has_invalid_tag() const { return tag_ == Tag::Invalid; }
bool is_response() const { return tag_ == Tag::kResponse; }
Controller_UpdatePowerStateMapping_Response& mutable_response();
template <typename T>
std::enable_if_t<std::is_convertible<T, Controller_UpdatePowerStateMapping_Response>::value && std::is_copy_assignable<T>::value>
set_response(const T& v) {
mutable_response() = v;
}
template <typename T>
std::enable_if_t<std::is_convertible<T, Controller_UpdatePowerStateMapping_Response>::value && std::is_move_assignable<T>::value>
set_response(T&& v) {
mutable_response() = std::move(v);
}
Controller_UpdatePowerStateMapping_Response const & response() const { return response_; }
bool is_err() const { return tag_ == Tag::kErr; }
int32_t& mutable_err();
template <typename T>
std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
set_err(const T& v) {
mutable_err() = v;
}
template <typename T>
std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
set_err(T&& v) {
mutable_err() = std::move(v);
}
int32_t const & err() const { return err_; }
Tag which() const { return tag_; }
static constexpr const fidl_type_t* Type = &fuchsia_device_Controller_UpdatePowerStateMapping_ResultTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 8;
[[maybe_unused]]
static constexpr uint32_t MaxOutOfLine = 0;
private:
void Destroy();
void MoveImpl_(Controller_UpdatePowerStateMapping_Result&& other);
static void SizeAndOffsetAssertionHelper();
Tag tag_;
union {
Controller_UpdatePowerStateMapping_Response response_;
int32_t err_;
};
};
extern "C" const fidl_type_t fuchsia_device_ControllerBindRequestTable;
extern "C" const fidl_type_t fuchsia_device_ControllerBindResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerScheduleUnbindResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerGetDriverNameResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerGetDeviceNameResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerGetTopologicalPathResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerGetEventHandleResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerSetDriverLogFlagsResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerDebugSuspendResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerDebugResumeResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerRunCompatibilityTestsResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerGetDevicePowerCapsResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerUpdatePowerStateMappingRequestTable;
extern "C" const fidl_type_t fuchsia_device_ControllerUpdatePowerStateMappingResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerGetPowerStateMappingResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerSuspendRequestTable;
extern "C" const fidl_type_t fuchsia_device_ControllerSuspendResponseTable;
extern "C" const fidl_type_t fuchsia_device_ControllerResumeRequestTable;
extern "C" const fidl_type_t fuchsia_device_ControllerResumeResponseTable;
// Interface for manipulating a device in a devhost
class Controller final {
Controller() = delete;
public:
struct BindResponse final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
int32_t status;
static constexpr const fidl_type_t* Type = &fuchsia_device_ControllerBindResponseTable;
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 BindRequest final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
::fidl::StringView driver;
static constexpr const fidl_type_t* Type = &fuchsia_device_ControllerBindRequestTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 32;
static constexpr uint32_t MaxOutOfLine = 1024;
static constexpr bool HasFlexibleEnvelope = false;
static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
::fidl::internal::TransactionalMessageKind::kRequest;
using ResponseType = BindResponse;
};
struct ScheduleUnbindResponse final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
int32_t status;
static constexpr const fidl_type_t* Type = &fuchsia_device_ControllerScheduleUnbindResponseTable;
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 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 = &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 ::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 = &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 ::fidl::internal::TransactionalMessageKind MessageKind =
::fidl::internal::TransactionalMessageKind::kResponse;
};
using GetDeviceNameRequest = ::fidl::AnyZeroArgMessage;
struct GetTopologicalPathResponse final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
int32_t status;
::fidl::StringView path;
static constexpr const fidl_type_t* Type = &fuchsia_device_ControllerGetTopologicalPathResponseTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 40;
static constexpr uint32_t MaxOutOfLine = 1024;
static constexpr bool HasFlexibleEnvelope = false;
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 = &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 ::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 = nullptr;
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 GetDriverLogFlagsRequest = ::fidl::AnyZeroArgMessage;
struct SetDriverLogFlagsResponse final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
int32_t status;
static constexpr const fidl_type_t* Type = &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 ::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 = nullptr;
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 = SetDriverLogFlagsResponse;
};
struct DebugSuspendResponse final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
int32_t status;
static constexpr const fidl_type_t* Type = &fuchsia_device_ControllerDebugSuspendResponseTable;
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 DebugSuspendRequest = ::fidl::AnyZeroArgMessage;
struct DebugResumeResponse final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
int32_t status;
static constexpr const fidl_type_t* Type = &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 ::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 = &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 ::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 = nullptr;
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 = RunCompatibilityTestsResponse;
};
struct GetDevicePowerCapsResponse final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
Controller_GetDevicePowerCaps_Result result;
static constexpr const fidl_type_t* Type = &fuchsia_device_ControllerGetDevicePowerCapsResponseTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 144;
static constexpr uint32_t MaxOutOfLine = 0;
static constexpr bool HasFlexibleEnvelope = false;
static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
::fidl::internal::TransactionalMessageKind::kResponse;
};
using GetDevicePowerCapsRequest = ::fidl::AnyZeroArgMessage;
struct UpdatePowerStateMappingResponse final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
Controller_UpdatePowerStateMapping_Result result;
static constexpr const fidl_type_t* Type = &fuchsia_device_ControllerUpdatePowerStateMappingResponseTable;
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 UpdatePowerStateMappingRequest final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
::fidl::Array<SystemPowerStateInfo, 6> mapping;
static constexpr const fidl_type_t* Type = &fuchsia_device_ControllerUpdatePowerStateMappingRequestTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 64;
static constexpr uint32_t MaxOutOfLine = 0;
static constexpr bool HasFlexibleEnvelope = false;
static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
::fidl::internal::TransactionalMessageKind::kRequest;
using ResponseType = UpdatePowerStateMappingResponse;
};
struct GetPowerStateMappingResponse final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
Controller_GetPowerStateMapping_Result result;
static constexpr const fidl_type_t* Type = &fuchsia_device_ControllerGetPowerStateMappingResponseTable;
static constexpr uint32_t MaxNumHandles = 0;
static constexpr uint32_t PrimarySize = 72;
static constexpr uint32_t MaxOutOfLine = 0;
static constexpr bool HasFlexibleEnvelope = false;
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;
DevicePowerState out_state;
static constexpr const fidl_type_t* Type = &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 ::fidl::internal::TransactionalMessageKind MessageKind =
::fidl::internal::TransactionalMessageKind::kResponse;
};
struct SuspendRequest final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
DevicePowerState requested_state;
static constexpr const fidl_type_t* Type = &fuchsia_device_ControllerSuspendRequestTable;
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 = SuspendResponse;
};
struct ResumeResponse final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
Controller_Resume_Result result;
static constexpr const fidl_type_t* Type = &fuchsia_device_ControllerResumeResponseTable;
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 ResumeRequest final {
FIDL_ALIGNDECL
fidl_message_header_t _hdr;
DevicePowerState requested_state;
static constexpr const fidl_type_t* Type = &fuchsia_device_ControllerResumeRequestTable;
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 = ResumeResponse;
};
// 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 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 DebugSuspend_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
public:
DebugSuspend_Impl(zx::unowned_channel _client_end);
~DebugSuspend_Impl() = default;
DebugSuspend_Impl(DebugSuspend_Impl&& other) = default;
DebugSuspend_Impl& operator=(DebugSuspend_Impl&& other) = default;
using 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 UpdatePowerStateMapping_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
public:
UpdatePowerStateMapping_Impl(zx::unowned_channel _client_end, ::fidl::Array<SystemPowerStateInfo, 6> 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, 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, 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*;
};
public:
using Bind = Bind_Impl<BindResponse>;
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 DebugSuspend = DebugSuspend_Impl<DebugSuspendResponse>;
using DebugResume = DebugResume_Impl<DebugResumeResponse>;
using RunCompatibilityTests = RunCompatibilityTests_Impl<RunCompatibilityTestsResponse>;
using GetDevicePowerCaps = GetDevicePowerCaps_Impl<GetDevicePowerCapsResponse>;
using UpdatePowerStateMapping = UpdatePowerStateMapping_Impl<UpdatePowerStateMappingResponse>;
using GetPowerStateMapping = GetPowerStateMapping_Impl<GetPowerStateMappingResponse>;
using Suspend = Suspend_Impl<SuspendResponse>;
using Resume = Resume_Impl<ResumeResponse>;
};
// 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 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 DebugSuspend_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
public:
DebugSuspend_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
~DebugSuspend_Impl() = default;
DebugSuspend_Impl(DebugSuspend_Impl&& other) = default;
DebugSuspend_Impl& operator=(DebugSuspend_Impl&& other) = default;
using 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 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<SystemPowerStateInfo, 6> 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, 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, 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*;
};
public:
using Bind = Bind_Impl<BindResponse>;
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 DebugSuspend = DebugSuspend_Impl<DebugSuspendResponse>;
using DebugResume = DebugResume_Impl<DebugResumeResponse>;
using RunCompatibilityTests = RunCompatibilityTests_Impl<RunCompatibilityTestsResponse>;
using GetDevicePowerCaps = GetDevicePowerCaps_Impl<GetDevicePowerCapsResponse>;
using UpdatePowerStateMapping = UpdatePowerStateMapping_Impl<UpdatePowerStateMappingResponse>;
using GetPowerStateMapping = GetPowerStateMapping_Impl<GetPowerStateMappingResponse>;
using Suspend = Suspend_Impl<SuspendResponse>;
using Resume = Resume_Impl<ResumeResponse>;
};
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 24 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);
// Disconnect this device and allow its parent to be bound again.
// This may not complete before it returns.
// Allocates 40 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 suspend hook
// Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
ResultOf::DebugSuspend DebugSuspend();
// Debug command: execute the device's suspend hook
// Caller provides the backing storage for FIDL message via request and response buffers.
UnownedResultOf::DebugSuspend DebugSuspend(::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 160 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);
// 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 88 bytes of message buffer on the stack. No heap allocation necessary.
ResultOf::UpdatePowerStateMapping UpdatePowerStateMapping(::fidl::Array<SystemPowerStateInfo, 6> 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<SystemPowerStateInfo, 6> 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 88 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. TODO(ravoorir): At the moment, this will call the suspend hook only on this device.
// In a future change, this api will result in suspend hook being called on all the children and
// descendants before transitioning this device.
// On success, the out_state is same as requested_state.
// On failure, the out_state is the state the device can go into at this point, depending
// on the configuration of its children. For example, a device cannot go into the
// requested_state, if the requested_state does not support a descendant's wake configuration.
// Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
ResultOf::Suspend Suspend(DevicePowerState requested_state);
// Transition this device from a working to a sleep state or from a sleep state to a deeper sleep
// state. TODO(ravoorir): At the moment, this will call the suspend hook only on this device.
// In a future change, this api will result in suspend hook being called on all the children and
// descendants before transitioning this device.
// On success, the out_state is same as requested_state.
// On failure, the out_state is the state the device can go into at this point, depending
// on the configuration of its children. For example, a device cannot go into the
// requested_state, if the requested_state does not support a descendant's wake configuration.
// Caller provides the backing storage for FIDL message via request and response buffers.
UnownedResultOf::Suspend Suspend(::fidl::BytePart _request_buffer, DevicePowerState requested_state, ::fidl::BytePart _response_buffer);
// Transition this device from a sleep state to a working state.
// TODO(ravoorir): At the moment, this will call the resume hook only on this device.
// In a future change, this api will result in resume hook being called on all the children
// after the current device is transitioned.
// On success, the out_state has the actual state of the device. The out_state could be
// different from the requested_state, if the device could not resume to the requested
// performant state, but the device could resume to a working state.
// Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
ResultOf::Resume Resume(DevicePowerState requested_state);
// Transition this device from a sleep state to a working state.
// TODO(ravoorir): At the moment, this will call the resume hook only on this device.
// In a future change, this api will result in resume hook being called on all the children
// after the current device is transitioned.
// On success, the out_state has the actual state of the device. The out_state could be
// different from the requested_state, if the device could not resume to the requested
// performant state, but the device could resume to a working state.
// Caller provides the backing storage for FIDL message via request and response buffers.
UnownedResultOf::Resume Resume(::fidl::BytePart _request_buffer, DevicePowerState requested_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 24 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);
// Disconnect this device and allow its parent to be bound again.
// This may not complete before it returns.
// Allocates 40 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 suspend hook
// Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
static ResultOf::DebugSuspend DebugSuspend(zx::unowned_channel _client_end);
// Debug command: execute the device's suspend hook
// Caller provides the backing storage for FIDL message via request and response buffers.
static UnownedResultOf::DebugSuspend DebugSuspend(zx::unowned_channel _client_end, ::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 160 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);
// 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 88 bytes of message buffer on the stack. No heap allocation necessary.
static ResultOf::UpdatePowerStateMapping UpdatePowerStateMapping(zx::unowned_channel _client_end, ::fidl::Array<SystemPowerStateInfo, 6> 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<SystemPowerStateInfo, 6> 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 88 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. TODO(ravoorir): At the moment, this will call the suspend hook only on this device.
// In a future change, this api will result in suspend hook being called on all the children and
// descendants before transitioning this device.
// On success, the out_state is same as requested_state.
// On failure, the out_state is the state the device can go into at this point, depending
// on the configuration of its children. For example, a device cannot go into the
// requested_state, if the requested_state does not support a descendant's wake configuration.
// Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
static ResultOf::Suspend Suspend(zx::unowned_channel _client_end, DevicePowerState requested_state);
// Transition this device from a working to a sleep state or from a sleep state to a deeper sleep
// state. TODO(ravoorir): At the moment, this will call the suspend hook only on this device.
// In a future change, this api will result in suspend hook being called on all the children and
// descendants before transitioning this device.
// On success, the out_state is same as requested_state.
// On failure, the out_state is the state the device can go into at this point, depending
// on the configuration of its children. For example, a device cannot go into the
// requested_state, if the requested_state does not support a descendant's wake configuration.
// 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, DevicePowerState requested_state, ::fidl::BytePart _response_buffer);
// Transition this device from a sleep state to a working state.
// TODO(ravoorir): At the moment, this will call the resume hook only on this device.
// In a future change, this api will result in resume hook being called on all the children
// after the current device is transitioned.
// On success, the out_state has the actual state of the device. The out_state could be
// different from the requested_state, if the device could not resume to the requested
// performant state, but the device could resume to a working state.
// Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
static ResultOf::Resume Resume(zx::unowned_channel _client_end, DevicePowerState requested_state);
// Transition this device from a sleep state to a working state.
// TODO(ravoorir): At the moment, this will call the resume hook only on this device.
// In a future change, this api will result in resume hook being called on all the children
// after the current device is transitioned.
// On success, the out_state has the actual state of the device. The out_state could be
// different from the requested_state, if the device could not resume to the requested
// performant state, but the device could resume 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, DevicePowerState requested_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);
// 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 suspend hook
static ::fidl::DecodeResult<DebugSuspendResponse> DebugSuspend(zx::unowned_channel _client_end, ::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);
// 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. TODO(ravoorir): At the moment, this will call the suspend hook only on this device.
// In a future change, this api will result in suspend hook being called on all the children and
// descendants before transitioning this device.
// On success, the out_state is same as requested_state.
// On failure, the out_state is the state the device can go into at this point, depending
// on the configuration of its children. For example, a device cannot go into the
// requested_state, if the requested_state does not support a descendant's wake configuration.
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.
// TODO(ravoorir): At the moment, this will call the resume hook only on this device.
// In a future change, this api will result in resume hook being called on all the children
// after the current device is transitioned.
// On success, the out_state has the actual state of the device. The out_state could be
// different from the requested_state, if the device could not resume to the requested
// performant state, but the device could resume to a working state.
static ::fidl::DecodeResult<ResumeResponse> Resume(zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResumeRequest> 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(int32_t status);
void Reply(::fidl::BytePart _buffer, int32_t status);
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 ScheduleUnbindCompleterBase : public _Base {
public:
void Reply(int32_t status);
void Reply(::fidl::BytePart _buffer, int32_t status);
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(int32_t status, ::fidl::StringView path);
void Reply(::fidl::BytePart _buffer, int32_t status, ::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 DebugSuspendCompleterBase : public _Base {
public:
void Reply(int32_t status);
void Reply(::fidl::BytePart _buffer, int32_t status);
void Reply(::fidl::DecodedMessage<DebugSuspendResponse> params);
protected:
using ::fidl::CompleterBase::CompleterBase;
};
using DebugSuspendCompleter = ::fidl::Completer<DebugSuspendCompleterBase>;
virtual void DebugSuspend(DebugSuspendCompleter::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(Controller_GetDevicePowerCaps_Result result);
void Reply(::fidl::BytePart _buffer, Controller_GetDevicePowerCaps_Result result);
void Reply(::fidl::DecodedMessage<GetDevicePowerCapsResponse> params);
protected:
using ::fidl::CompleterBase::CompleterBase;
};
using GetDevicePowerCapsCompleter = ::fidl::Completer<GetDevicePowerCapsCompleterBase>;
virtual void GetDevicePowerCaps(GetDevicePowerCapsCompleter::Sync _completer) = 0;
class UpdatePowerStateMappingCompleterBase : public _Base {
public:
void Reply(Controller_UpdatePowerStateMapping_Result result);
void Reply(::fidl::BytePart _buffer, Controller_UpdatePowerStateMapping_Result result);
void Reply(::fidl::DecodedMessage<UpdatePowerStateMappingResponse> params);
protected:
using ::fidl::CompleterBase::CompleterBase;
};
using UpdatePowerStateMappingCompleter = ::fidl::Completer<UpdatePowerStateMappingCompleterBase>;
virtual void UpdatePowerStateMapping(::fidl::Array<SystemPowerStateInfo, 6> mapping, UpdatePowerStateMappingCompleter::Sync _completer) = 0;
class GetPowerStateMappingCompleterBase : public _Base {
public:
void Reply(Controller_GetPowerStateMapping_Result result);
void Reply(::fidl::BytePart _buffer, Controller_GetPowerStateMapping_Result result);
void Reply(::fidl::DecodedMessage<GetPowerStateMappingResponse> params);
protected:
using ::fidl::CompleterBase::CompleterBase;
};
using GetPowerStateMappingCompleter = ::fidl::Completer<GetPowerStateMappingCompleterBase>;
virtual void GetPowerStateMapping(GetPowerStateMappingCompleter::Sync _completer) = 0;