Trait qapi::Enum

pub unsafe trait Enum: DeserializeOwned + FromStr + Copy + 'static {
    const COUNT: usize;
    const VARIANTS: &'static [Self];
    const NAMES: &'static [&'static str];

    // Required method
    fn discriminant(&self) -> usize;

    // Provided methods
    fn name(&self) -> &'static str { ... }
    fn from_name(s: &str) -> Option<Self> { ... }
}

Required Associated Constants

const COUNT: usize

const VARIANTS: &'static [Self]

const NAMES: &'static [&'static str]

Required Methods

fn discriminant(&self) -> usize

Provided Methods

fn name(&self) -> &'static str

fn from_name(s: &str) -> Option<Self>

Implementations on Foreign Types

impl Enum for OffAutoPCIBAR

fn discriminant(&self) -> usize

const COUNT: usize = 8usize

const VARIANTS: &'static [OffAutoPCIBAR] = &[OffAutoPCIBAR::off, OffAutoPCIBAR::auto, OffAutoPCIBAR::bar0, OffAutoPCIBAR::bar1, OffAutoPCIBAR::bar2, OffAutoPCIBAR::bar3, OffAutoPCIBAR::bar4, OffAutoPCIBAR::bar5]

const NAMES: &'static [&'static str] = &["off", "auto", "bar0", "bar1", "bar2", "bar3", "bar4", "bar5"]

impl Enum for TraceEventState

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [TraceEventState] = &[TraceEventState::unavailable, TraceEventState::disabled, TraceEventState::enabled]

const NAMES: &'static [&'static str] = &["unavailable", "disabled", "enabled"]

impl Enum for HmatLBMemoryHierarchy

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [HmatLBMemoryHierarchy] = &[HmatLBMemoryHierarchy::memory, HmatLBMemoryHierarchy::first_level, HmatLBMemoryHierarchy::second_level, HmatLBMemoryHierarchy::third_level]

const NAMES: &'static [&'static str] = &["memory", "first-level", "second-level", "third-level"]

impl Enum for DisplayType

fn discriminant(&self) -> usize

const COUNT: usize = 9usize

const VARIANTS: &'static [DisplayType] = &[DisplayType::default, DisplayType::none, DisplayType::gtk, DisplayType::sdl, DisplayType::egl_headless, DisplayType::curses, DisplayType::cocoa, DisplayType::spice_app, DisplayType::dbus]

const NAMES: &'static [&'static str] = &["default", "none", "gtk", "sdl", "egl-headless", "curses", "cocoa", "spice-app", "dbus"]

impl Enum for BlockExportRemoveMode

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [BlockExportRemoveMode] = &[BlockExportRemoveMode::safe, BlockExportRemoveMode::hard]

const NAMES: &'static [&'static str] = &["safe", "hard"]

impl Enum for CompatPolicyInput

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [CompatPolicyInput] = &[CompatPolicyInput::accept, CompatPolicyInput::reject, CompatPolicyInput::crash]

const NAMES: &'static [&'static str] = &["accept", "reject", "crash"]

impl Enum for MigrationParameter

fn discriminant(&self) -> usize

const COUNT: usize = 27usize

const VARIANTS: &'static [MigrationParameter] = &[MigrationParameter::announce_initial, MigrationParameter::announce_max, MigrationParameter::announce_rounds, MigrationParameter::announce_step, MigrationParameter::compress_level, MigrationParameter::compress_threads, MigrationParameter::decompress_threads, MigrationParameter::compress_wait_thread, MigrationParameter::throttle_trigger_threshold, MigrationParameter::cpu_throttle_initial, MigrationParameter::cpu_throttle_increment, MigrationParameter::cpu_throttle_tailslow, MigrationParameter::tls_creds, MigrationParameter::tls_hostname, MigrationParameter::tls_authz, MigrationParameter::max_bandwidth, MigrationParameter::downtime_limit, MigrationParameter::x_checkpoint_delay, MigrationParameter::block_incremental, MigrationParameter::multifd_channels, MigrationParameter::xbzrle_cache_size, MigrationParameter::max_postcopy_bandwidth, MigrationParameter::max_cpu_throttle, MigrationParameter::multifd_compression, MigrationParameter::multifd_zlib_level, MigrationParameter::multifd_zstd_level, MigrationParameter::block_bitmap_mapping]

const NAMES: &'static [&'static str] = &["announce-initial", "announce-max", "announce-rounds", "announce-step", "compress-level", "compress-threads", "decompress-threads", "compress-wait-thread", "throttle-trigger-threshold", "cpu-throttle-initial", "cpu-throttle-increment", "cpu-throttle-tailslow", "tls-creds", "tls-hostname", "tls-authz", "max-bandwidth", "downtime-limit", "x-checkpoint-delay", "block-incremental", "multifd-channels", "xbzrle-cache-size", "max-postcopy-bandwidth", "max-cpu-throttle", "multifd-compression", "multifd-zlib-level", "multifd-zstd-level", "block-bitmap-mapping"]

impl Enum for NFSTransport

fn discriminant(&self) -> usize

const COUNT: usize = 1usize

const VARIANTS: &'static [NFSTransport] = &[NFSTransport::inet]

const NAMES: &'static [&'static str] = &["inet"]

impl Enum for SocketAddressType

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [SocketAddressType] = &[SocketAddressType::inet, SocketAddressType::unix, SocketAddressType::vsock, SocketAddressType::fd]

const NAMES: &'static [&'static str] = &["inet", "unix", "vsock", "fd"]

impl Enum for QCryptoAkCipherKeyType

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [QCryptoAkCipherKeyType] = &[QCryptoAkCipherKeyType::public, QCryptoAkCipherKeyType::private]

const NAMES: &'static [&'static str] = &["public", "private"]

impl Enum for S390CrashReason

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [S390CrashReason] = &[S390CrashReason::unknown, S390CrashReason::disabled_wait, S390CrashReason::extint_loop, S390CrashReason::pgmint_loop, S390CrashReason::opint_loop]

const NAMES: &'static [&'static str] = &["unknown", "disabled-wait", "extint-loop", "pgmint-loop", "opint-loop"]

impl Enum for ShutdownCause

fn discriminant(&self) -> usize

const COUNT: usize = 11usize

const VARIANTS: &'static [ShutdownCause] = &[ShutdownCause::none, ShutdownCause::host_error, ShutdownCause::host_qmp_quit, ShutdownCause::host_qmp_system_reset, ShutdownCause::host_signal, ShutdownCause::host_ui, ShutdownCause::guest_shutdown, ShutdownCause::guest_reset, ShutdownCause::guest_panic, ShutdownCause::subsystem_reset, ShutdownCause::snapshot_load]

const NAMES: &'static [&'static str] = &["none", "host-error", "host-qmp-quit", "host-qmp-system-reset", "host-signal", "host-ui", "guest-shutdown", "guest-reset", "guest-panic", "subsystem-reset", "snapshot-load"]

impl Enum for BlockdevDetectZeroesOptions

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [BlockdevDetectZeroesOptions] = &[BlockdevDetectZeroesOptions::off, BlockdevDetectZeroesOptions::on, BlockdevDetectZeroesOptions::unmap]

const NAMES: &'static [&'static str] = &["off", "on", "unmap"]

impl Enum for MonitorMode

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [MonitorMode] = &[MonitorMode::readline, MonitorMode::control]

const NAMES: &'static [&'static str] = &["readline", "control"]

impl Enum for DumpGuestMemoryFormat

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [DumpGuestMemoryFormat] = &[DumpGuestMemoryFormat::elf, DumpGuestMemoryFormat::kdump_zlib, DumpGuestMemoryFormat::kdump_lzo, DumpGuestMemoryFormat::kdump_snappy, DumpGuestMemoryFormat::win_dmp]

const NAMES: &'static [&'static str] = &["elf", "kdump-zlib", "kdump-lzo", "kdump-snappy", "win-dmp"]

impl Enum for TransactionActionKind

fn discriminant(&self) -> usize

const COUNT: usize = 12usize

const VARIANTS: &'static [TransactionActionKind] = &[TransactionActionKind::abort, TransactionActionKind::block_dirty_bitmap_add, TransactionActionKind::block_dirty_bitmap_remove, TransactionActionKind::block_dirty_bitmap_clear, TransactionActionKind::block_dirty_bitmap_enable, TransactionActionKind::block_dirty_bitmap_disable, TransactionActionKind::block_dirty_bitmap_merge, TransactionActionKind::blockdev_backup, TransactionActionKind::blockdev_snapshot, TransactionActionKind::blockdev_snapshot_internal_sync, TransactionActionKind::blockdev_snapshot_sync, TransactionActionKind::drive_backup]

const NAMES: &'static [&'static str] = &["abort", "block-dirty-bitmap-add", "block-dirty-bitmap-remove", "block-dirty-bitmap-clear", "block-dirty-bitmap-enable", "block-dirty-bitmap-disable", "block-dirty-bitmap-merge", "blockdev-backup", "blockdev-snapshot", "blockdev-snapshot-internal-sync", "blockdev-snapshot-sync", "drive-backup"]

impl Enum for BitmapSyncMode

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [BitmapSyncMode] = &[BitmapSyncMode::on_success, BitmapSyncMode::never, BitmapSyncMode::always]

const NAMES: &'static [&'static str] = &["on-success", "never", "always"]

impl Enum for QCryptoCipherMode

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [QCryptoCipherMode] = &[QCryptoCipherMode::ecb, QCryptoCipherMode::cbc, QCryptoCipherMode::xts, QCryptoCipherMode::ctr]

const NAMES: &'static [&'static str] = &["ecb", "cbc", "xts", "ctr"]

impl Enum for QCryptoBlockLUKSKeyslotState

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [QCryptoBlockLUKSKeyslotState] = &[QCryptoBlockLUKSKeyslotState::active, QCryptoBlockLUKSKeyslotState::inactive]

const NAMES: &'static [&'static str] = &["active", "inactive"]

impl Enum for BlkdebugEvent

fn discriminant(&self) -> usize

const COUNT: usize = 48usize

const VARIANTS: &'static [BlkdebugEvent] = &[BlkdebugEvent::l1_update, BlkdebugEvent::l1_grow_alloc_table, BlkdebugEvent::l1_grow_write_table, BlkdebugEvent::l1_grow_activate_table, BlkdebugEvent::l2_load, BlkdebugEvent::l2_update, BlkdebugEvent::l2_update_compressed, BlkdebugEvent::l2_alloc_cow_read, BlkdebugEvent::l2_alloc_write, BlkdebugEvent::read_aio, BlkdebugEvent::read_backing_aio, BlkdebugEvent::read_compressed, BlkdebugEvent::write_aio, BlkdebugEvent::write_compressed, BlkdebugEvent::vmstate_load, BlkdebugEvent::vmstate_save, BlkdebugEvent::cow_read, BlkdebugEvent::cow_write, BlkdebugEvent::reftable_load, BlkdebugEvent::reftable_grow, BlkdebugEvent::reftable_update, BlkdebugEvent::refblock_load, BlkdebugEvent::refblock_update, BlkdebugEvent::refblock_update_part, BlkdebugEvent::refblock_alloc, BlkdebugEvent::refblock_alloc_hookup, BlkdebugEvent::refblock_alloc_write, BlkdebugEvent::refblock_alloc_write_blocks, BlkdebugEvent::refblock_alloc_write_table, BlkdebugEvent::refblock_alloc_switch_table, BlkdebugEvent::cluster_alloc, BlkdebugEvent::cluster_alloc_bytes, BlkdebugEvent::cluster_free, BlkdebugEvent::flush_to_os, BlkdebugEvent::flush_to_disk, BlkdebugEvent::pwritev_rmw_head, BlkdebugEvent::pwritev_rmw_after_head, BlkdebugEvent::pwritev_rmw_tail, BlkdebugEvent::pwritev_rmw_after_tail, BlkdebugEvent::pwritev, BlkdebugEvent::pwritev_zero, BlkdebugEvent::pwritev_done, BlkdebugEvent::empty_image_prepare, BlkdebugEvent::l1_shrink_write_table, BlkdebugEvent::l1_shrink_free_l2_clusters, BlkdebugEvent::cor_write, BlkdebugEvent::cluster_alloc_space, BlkdebugEvent::none]

const NAMES: &'static [&'static str] = &["l1_update", "l1_grow_alloc_table", "l1_grow_write_table", "l1_grow_activate_table", "l2_load", "l2_update", "l2_update_compressed", "l2_alloc_cow_read", "l2_alloc_write", "read_aio", "read_backing_aio", "read_compressed", "write_aio", "write_compressed", "vmstate_load", "vmstate_save", "cow_read", "cow_write", "reftable_load", "reftable_grow", "reftable_update", "refblock_load", "refblock_update", "refblock_update_part", "refblock_alloc", "refblock_alloc_hookup", "refblock_alloc_write", "refblock_alloc_write_blocks", "refblock_alloc_write_table", "refblock_alloc_switch_table", "cluster_alloc", "cluster_alloc_bytes", "cluster_free", "flush_to_os", "flush_to_disk", "pwritev_rmw_head", "pwritev_rmw_after_head", "pwritev_rmw_tail", "pwritev_rmw_after_tail", "pwritev", "pwritev_zero", "pwritev_done", "empty_image_prepare", "l1_shrink_write_table", "l1_shrink_free_l2_clusters", "cor_write", "cluster_alloc_space", "none"]

impl Enum for DirtyRateMeasureMode

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [DirtyRateMeasureMode] = &[DirtyRateMeasureMode::page_sampling, DirtyRateMeasureMode::dirty_ring, DirtyRateMeasureMode::dirty_bitmap]

const NAMES: &'static [&'static str] = &["page-sampling", "dirty-ring", "dirty-bitmap"]

impl Enum for GuestPanicAction

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [GuestPanicAction] = &[GuestPanicAction::pause, GuestPanicAction::poweroff, GuestPanicAction::run]

const NAMES: &'static [&'static str] = &["pause", "poweroff", "run"]

impl Enum for GuestPanicInformationType

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [GuestPanicInformationType] = &[GuestPanicInformationType::hyper_v, GuestPanicInformationType::s390]

const NAMES: &'static [&'static str] = &["hyper-v", "s390"]

impl Enum for JobStatus

fn discriminant(&self) -> usize

const COUNT: usize = 11usize

const VARIANTS: &'static [JobStatus] = &[JobStatus::undefined, JobStatus::created, JobStatus::running, JobStatus::paused, JobStatus::ready, JobStatus::standby, JobStatus::waiting, JobStatus::pending, JobStatus::aborting, JobStatus::concluded, JobStatus::null]

const NAMES: &'static [&'static str] = &["undefined", "created", "running", "paused", "ready", "standby", "waiting", "pending", "aborting", "concluded", "null"]

impl Enum for PanicAction

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [PanicAction] = &[PanicAction::pause, PanicAction::shutdown, PanicAction::exit_failure, PanicAction::none]

const NAMES: &'static [&'static str] = &["pause", "shutdown", "exit-failure", "none"]

impl Enum for MemoryDeviceInfoKind

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [MemoryDeviceInfoKind] = &[MemoryDeviceInfoKind::dimm, MemoryDeviceInfoKind::nvdimm, MemoryDeviceInfoKind::virtio_pmem, MemoryDeviceInfoKind::virtio_mem, MemoryDeviceInfoKind::sgx_epc]

const NAMES: &'static [&'static str] = &["dimm", "nvdimm", "virtio-pmem", "virtio-mem", "sgx-epc"]

impl Enum for RebootAction

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [RebootAction] = &[RebootAction::reset, RebootAction::shutdown]

const NAMES: &'static [&'static str] = &["reset", "shutdown"]

impl Enum for InputAxis

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [InputAxis] = &[InputAxis::x, InputAxis::y]

const NAMES: &'static [&'static str] = &["x", "y"]

impl Enum for SmbiosEntryPointType

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [SmbiosEntryPointType] = &[SmbiosEntryPointType::_32, SmbiosEntryPointType::_64]

const NAMES: &'static [&'static str] = &["32", "64"]

impl Enum for BlkdebugIOType

fn discriminant(&self) -> usize

const COUNT: usize = 6usize

const VARIANTS: &'static [BlkdebugIOType] = &[BlkdebugIOType::read, BlkdebugIOType::write, BlkdebugIOType::write_zeroes, BlkdebugIOType::discard, BlkdebugIOType::flush, BlkdebugIOType::block_status]

const NAMES: &'static [&'static str] = &["read", "write", "write-zeroes", "discard", "flush", "block-status"]

impl Enum for GrabToggleKeys

fn discriminant(&self) -> usize

const COUNT: usize = 6usize

const VARIANTS: &'static [GrabToggleKeys] = &[GrabToggleKeys::ctrl_ctrl, GrabToggleKeys::alt_alt, GrabToggleKeys::shift_shift, GrabToggleKeys::meta_meta, GrabToggleKeys::scrolllock, GrabToggleKeys::ctrl_scrolllock]

const NAMES: &'static [&'static str] = &["ctrl-ctrl", "alt-alt", "shift-shift", "meta-meta", "scrolllock", "ctrl-scrolllock"]

impl Enum for BlockdevVhdxSubformat

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [BlockdevVhdxSubformat] = &[BlockdevVhdxSubformat::dynamic, BlockdevVhdxSubformat::fixed]

const NAMES: &'static [&'static str] = &["dynamic", "fixed"]

impl Enum for BlockDeviceIoStatus

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [BlockDeviceIoStatus] = &[BlockDeviceIoStatus::ok, BlockDeviceIoStatus::failed, BlockDeviceIoStatus::nospace]

const NAMES: &'static [&'static str] = &["ok", "failed", "nospace"]

impl Enum for NetworkAddressFamily

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [NetworkAddressFamily] = &[NetworkAddressFamily::ipv4, NetworkAddressFamily::ipv6, NetworkAddressFamily::unix, NetworkAddressFamily::vsock, NetworkAddressFamily::unknown]

const NAMES: &'static [&'static str] = &["ipv4", "ipv6", "unix", "vsock", "unknown"]

impl Enum for CommandLineParameterType

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [CommandLineParameterType] = &[CommandLineParameterType::string, CommandLineParameterType::boolean, CommandLineParameterType::number, CommandLineParameterType::size]

const NAMES: &'static [&'static str] = &["string", "boolean", "number", "size"]

impl Enum for ImageInfoSpecificKind

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [ImageInfoSpecificKind] = &[ImageInfoSpecificKind::qcow2, ImageInfoSpecificKind::vmdk, ImageInfoSpecificKind::luks, ImageInfoSpecificKind::rbd, ImageInfoSpecificKind::file]

const NAMES: &'static [&'static str] = &["qcow2", "vmdk", "luks", "rbd", "file"]

impl Enum for QCryptoHashAlgorithm

fn discriminant(&self) -> usize

const COUNT: usize = 7usize

const VARIANTS: &'static [QCryptoHashAlgorithm] = &[QCryptoHashAlgorithm::md5, QCryptoHashAlgorithm::sha1, QCryptoHashAlgorithm::sha224, QCryptoHashAlgorithm::sha256, QCryptoHashAlgorithm::sha384, QCryptoHashAlgorithm::sha512, QCryptoHashAlgorithm::ripemd160]

const NAMES: &'static [&'static str] = &["md5", "sha1", "sha224", "sha256", "sha384", "sha512", "ripemd160"]

impl Enum for RxState

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [RxState] = &[RxState::normal, RxState::none, RxState::all]

const NAMES: &'static [&'static str] = &["normal", "none", "all"]

impl Enum for MigrationStatus

fn discriminant(&self) -> usize

const COUNT: usize = 14usize

const VARIANTS: &'static [MigrationStatus] = &[MigrationStatus::none, MigrationStatus::setup, MigrationStatus::cancelling, MigrationStatus::cancelled, MigrationStatus::active, MigrationStatus::postcopy_active, MigrationStatus::postcopy_paused, MigrationStatus::postcopy_recover, MigrationStatus::completed, MigrationStatus::failed, MigrationStatus::colo, MigrationStatus::pre_switchover, MigrationStatus::device, MigrationStatus::wait_unplug]

const NAMES: &'static [&'static str] = &["none", "setup", "cancelling", "cancelled", "active", "postcopy-active", "postcopy-paused", "postcopy-recover", "completed", "failed", "colo", "pre-switchover", "device", "wait-unplug"]

impl Enum for QCryptodevBackendServiceType

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [QCryptodevBackendServiceType] = &[QCryptodevBackendServiceType::cipher, QCryptodevBackendServiceType::hash, QCryptodevBackendServiceType::mac, QCryptodevBackendServiceType::aead, QCryptodevBackendServiceType::akcipher]

const NAMES: &'static [&'static str] = &["cipher", "hash", "mac", "aead", "akcipher"]

impl Enum for AudioFormat

fn discriminant(&self) -> usize

const COUNT: usize = 7usize

const VARIANTS: &'static [AudioFormat] = &[AudioFormat::u8, AudioFormat::s8, AudioFormat::u16, AudioFormat::s16, AudioFormat::u32, AudioFormat::s32, AudioFormat::f32]

const NAMES: &'static [&'static str] = &["u8", "s8", "u16", "s16", "u32", "s32", "f32"]

impl Enum for ReplicationMode

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [ReplicationMode] = &[ReplicationMode::primary, ReplicationMode::secondary]

const NAMES: &'static [&'static str] = &["primary", "secondary"]

impl Enum for CpuModelExpansionType

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [CpuModelExpansionType] = &[CpuModelExpansionType::static_, CpuModelExpansionType::full]

const NAMES: &'static [&'static str] = &["static", "full"]

impl Enum for KeyValueKind

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [KeyValueKind] = &[KeyValueKind::number, KeyValueKind::qcode]

const NAMES: &'static [&'static str] = &["number", "qcode"]

impl Enum for SchemaMetaType

fn discriminant(&self) -> usize

const COUNT: usize = 7usize

const VARIANTS: &'static [SchemaMetaType] = &[SchemaMetaType::builtin, SchemaMetaType::enum_, SchemaMetaType::array, SchemaMetaType::object, SchemaMetaType::alternate, SchemaMetaType::command, SchemaMetaType::event]

const NAMES: &'static [&'static str] = &["builtin", "enum", "array", "object", "alternate", "command", "event"]

impl Enum for DisplayReloadType

fn discriminant(&self) -> usize

const COUNT: usize = 1usize

const VARIANTS: &'static [DisplayReloadType] = &[DisplayReloadType::vnc]

const NAMES: &'static [&'static str] = &["vnc"]

impl Enum for Qcow2BitmapInfoFlags

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [Qcow2BitmapInfoFlags] = &[Qcow2BitmapInfoFlags::in_use, Qcow2BitmapInfoFlags::auto]

const NAMES: &'static [&'static str] = &["in-use", "auto"]

impl Enum for JobType

fn discriminant(&self) -> usize

const COUNT: usize = 9usize

const VARIANTS: &'static [JobType] = &[JobType::commit, JobType::stream, JobType::mirror, JobType::backup, JobType::create, JobType::amend, JobType::snapshot_load, JobType::snapshot_save, JobType::snapshot_delete]

const NAMES: &'static [&'static str] = &["commit", "stream", "mirror", "backup", "create", "amend", "snapshot-load", "snapshot-save", "snapshot-delete"]

impl Enum for FailoverStatus

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [FailoverStatus] = &[FailoverStatus::none, FailoverStatus::require, FailoverStatus::active, FailoverStatus::completed, FailoverStatus::relaunch]

const NAMES: &'static [&'static str] = &["none", "require", "active", "completed", "relaunch"]

impl Enum for CpuModelCompareResult

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [CpuModelCompareResult] = &[CpuModelCompareResult::incompatible, CpuModelCompareResult::identical, CpuModelCompareResult::superset, CpuModelCompareResult::subset]

const NAMES: &'static [&'static str] = &["incompatible", "identical", "superset", "subset"]

impl Enum for CpuS390State

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [CpuS390State] = &[CpuS390State::uninitialized, CpuS390State::stopped, CpuS390State::check_stop, CpuS390State::operating, CpuS390State::load]

const NAMES: &'static [&'static str] = &["uninitialized", "stopped", "check-stop", "operating", "load"]

impl Enum for QCryptoAkCipherAlgorithm

fn discriminant(&self) -> usize

const COUNT: usize = 1usize

const VARIANTS: &'static [QCryptoAkCipherAlgorithm] = &[QCryptoAkCipherAlgorithm::rsa]

const NAMES: &'static [&'static str] = &["rsa"]

impl Enum for COLOExitReason

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [COLOExitReason] = &[COLOExitReason::none, COLOExitReason::request, COLOExitReason::error, COLOExitReason::processing]

const NAMES: &'static [&'static str] = &["none", "request", "error", "processing"]

impl Enum for StatsUnit

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [StatsUnit] = &[StatsUnit::bytes, StatsUnit::seconds, StatsUnit::cycles, StatsUnit::boolean]

const NAMES: &'static [&'static str] = &["bytes", "seconds", "cycles", "boolean"]

impl Enum for HotKeyMod

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [HotKeyMod] = &[HotKeyMod::lctrl_lalt, HotKeyMod::lshift_lctrl_lalt, HotKeyMod::rctrl]

const NAMES: &'static [&'static str] = &["lctrl-lalt", "lshift-lctrl-lalt", "rctrl"]

impl Enum for BlockdevVmdkAdapterType

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [BlockdevVmdkAdapterType] = &[BlockdevVmdkAdapterType::ide, BlockdevVmdkAdapterType::buslogic, BlockdevVmdkAdapterType::lsilogic, BlockdevVmdkAdapterType::legacyESX]

const NAMES: &'static [&'static str] = &["ide", "buslogic", "lsilogic", "legacyESX"]

impl Enum for CxlUncorErrorType

fn discriminant(&self) -> usize

const COUNT: usize = 15usize

const VARIANTS: &'static [CxlUncorErrorType] = &[CxlUncorErrorType::cache_data_parity, CxlUncorErrorType::cache_address_parity, CxlUncorErrorType::cache_be_parity, CxlUncorErrorType::cache_data_ecc, CxlUncorErrorType::mem_data_parity, CxlUncorErrorType::mem_address_parity, CxlUncorErrorType::mem_be_parity, CxlUncorErrorType::mem_data_ecc, CxlUncorErrorType::reinit_threshold, CxlUncorErrorType::rsvd_encoding, CxlUncorErrorType::poison_received, CxlUncorErrorType::receiver_overflow, CxlUncorErrorType::internal, CxlUncorErrorType::cxl_ide_tx, CxlUncorErrorType::cxl_ide_rx]

const NAMES: &'static [&'static str] = &["cache-data-parity", "cache-address-parity", "cache-be-parity", "cache-data-ecc", "mem-data-parity", "mem-address-parity", "mem-be-parity", "mem-data-ecc", "reinit-threshold", "rsvd-encoding", "poison-received", "receiver-overflow", "internal", "cxl-ide-tx", "cxl-ide-rx"]

impl Enum for Qcow2OverlapCheckMode

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [Qcow2OverlapCheckMode] = &[Qcow2OverlapCheckMode::none, Qcow2OverlapCheckMode::constant, Qcow2OverlapCheckMode::cached, Qcow2OverlapCheckMode::all]

const NAMES: &'static [&'static str] = &["none", "constant", "cached", "all"]

impl Enum for QAuthZListPolicy

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [QAuthZListPolicy] = &[QAuthZListPolicy::deny, QAuthZListPolicy::allow]

const NAMES: &'static [&'static str] = &["deny", "allow"]

impl Enum for DataFormat

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [DataFormat] = &[DataFormat::utf8, DataFormat::base64]

const NAMES: &'static [&'static str] = &["utf8", "base64"]

impl Enum for QCryptodevBackendAlgType

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [QCryptodevBackendAlgType] = &[QCryptodevBackendAlgType::sym, QCryptodevBackendAlgType::asym]

const NAMES: &'static [&'static str] = &["sym", "asym"]

impl Enum for DirtyRateStatus

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [DirtyRateStatus] = &[DirtyRateStatus::unstarted, DirtyRateStatus::measuring, DirtyRateStatus::measured]

const NAMES: &'static [&'static str] = &["unstarted", "measuring", "measured"]

impl Enum for ChardevBackendKind

fn discriminant(&self) -> usize

const COUNT: usize = 22usize

const VARIANTS: &'static [ChardevBackendKind] = &[ChardevBackendKind::file, ChardevBackendKind::serial, ChardevBackendKind::parallel, ChardevBackendKind::pipe, ChardevBackendKind::socket, ChardevBackendKind::udp, ChardevBackendKind::pty, ChardevBackendKind::null, ChardevBackendKind::mux, ChardevBackendKind::msmouse, ChardevBackendKind::wctablet, ChardevBackendKind::braille, ChardevBackendKind::testdev, ChardevBackendKind::stdio, ChardevBackendKind::console, ChardevBackendKind::spicevmc, ChardevBackendKind::spiceport, ChardevBackendKind::qemu_vdagent, ChardevBackendKind::dbus, ChardevBackendKind::vc, ChardevBackendKind::ringbuf, ChardevBackendKind::memory]

const NAMES: &'static [&'static str] = &["file", "serial", "parallel", "pipe", "socket", "udp", "pty", "null", "mux", "msmouse", "wctablet", "braille", "testdev", "stdio", "console", "spicevmc", "spiceport", "qemu-vdagent", "dbus", "vc", "ringbuf", "memory"]

impl Enum for ImageFormat

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [ImageFormat] = &[ImageFormat::ppm, ImageFormat::png]

const NAMES: &'static [&'static str] = &["ppm", "png"]

impl Enum for HmatCacheAssociativity

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [HmatCacheAssociativity] = &[HmatCacheAssociativity::none, HmatCacheAssociativity::direct, HmatCacheAssociativity::complex]

const NAMES: &'static [&'static str] = &["none", "direct", "complex"]

impl Enum for ShutdownAction

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [ShutdownAction] = &[ShutdownAction::poweroff, ShutdownAction::pause]

const NAMES: &'static [&'static str] = &["poweroff", "pause"]

impl Enum for YankInstanceType

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [YankInstanceType] = &[YankInstanceType::block_node, YankInstanceType::chardev, YankInstanceType::migration]

const NAMES: &'static [&'static str] = &["block-node", "chardev", "migration"]

impl Enum for IscsiTransport

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [IscsiTransport] = &[IscsiTransport::tcp, IscsiTransport::iser]

const NAMES: &'static [&'static str] = &["tcp", "iser"]

impl Enum for QAuthZListFormat

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [QAuthZListFormat] = &[QAuthZListFormat::exact, QAuthZListFormat::glob]

const NAMES: &'static [&'static str] = &["exact", "glob"]

impl Enum for OnOffSplit

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [OnOffSplit] = &[OnOffSplit::on, OnOffSplit::off, OnOffSplit::split]

const NAMES: &'static [&'static str] = &["on", "off", "split"]

impl Enum for ReplayMode

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [ReplayMode] = &[ReplayMode::none, ReplayMode::record, ReplayMode::play]

const NAMES: &'static [&'static str] = &["none", "record", "play"]

impl Enum for DisplayGLMode

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [DisplayGLMode] = &[DisplayGLMode::off, DisplayGLMode::on, DisplayGLMode::core, DisplayGLMode::es]

const NAMES: &'static [&'static str] = &["off", "on", "core", "es"]

impl Enum for TpmModel

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [TpmModel] = &[TpmModel::tpm_tis, TpmModel::tpm_crb, TpmModel::tpm_spapr]

const NAMES: &'static [&'static str] = &["tpm-tis", "tpm-crb", "tpm-spapr"]

impl Enum for BlockdevVmdkSubformat

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [BlockdevVmdkSubformat] = &[BlockdevVmdkSubformat::monolithicSparse, BlockdevVmdkSubformat::monolithicFlat, BlockdevVmdkSubformat::twoGbMaxExtentSparse, BlockdevVmdkSubformat::twoGbMaxExtentFlat, BlockdevVmdkSubformat::streamOptimized]

const NAMES: &'static [&'static str] = &["monolithicSparse", "monolithicFlat", "twoGbMaxExtentSparse", "twoGbMaxExtentFlat", "streamOptimized"]

impl Enum for RbdImageEncryptionFormat

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [RbdImageEncryptionFormat] = &[RbdImageEncryptionFormat::luks, RbdImageEncryptionFormat::luks2, RbdImageEncryptionFormat::luks_any]

const NAMES: &'static [&'static str] = &["luks", "luks2", "luks-any"]

impl Enum for QapiErrorClass

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [QapiErrorClass] = &[QapiErrorClass::GenericError, QapiErrorClass::CommandNotFound, QapiErrorClass::DeviceNotActive, QapiErrorClass::DeviceNotFound, QapiErrorClass::KVMMissingCap]

const NAMES: &'static [&'static str] = &["GenericError", "CommandNotFound", "DeviceNotActive", "DeviceNotFound", "KVMMissingCap"]

impl Enum for QKeyCode

fn discriminant(&self) -> usize

const COUNT: usize = 162usize

const VARIANTS: &'static [QKeyCode] = &[QKeyCode::unmapped, QKeyCode::shift, QKeyCode::shift_r, QKeyCode::alt, QKeyCode::alt_r, QKeyCode::ctrl, QKeyCode::ctrl_r, QKeyCode::menu, QKeyCode::esc, QKeyCode::_1, QKeyCode::_2, QKeyCode::_3, QKeyCode::_4, QKeyCode::_5, QKeyCode::_6, QKeyCode::_7, QKeyCode::_8, QKeyCode::_9, QKeyCode::_0, QKeyCode::minus, QKeyCode::equal, QKeyCode::backspace, QKeyCode::tab, QKeyCode::q, QKeyCode::w, QKeyCode::e, QKeyCode::r, QKeyCode::t, QKeyCode::y, QKeyCode::u, QKeyCode::i, QKeyCode::o, QKeyCode::p, QKeyCode::bracket_left, QKeyCode::bracket_right, QKeyCode::ret, QKeyCode::a, QKeyCode::s, QKeyCode::d, QKeyCode::f, QKeyCode::g, QKeyCode::h, QKeyCode::j, QKeyCode::k, QKeyCode::l, QKeyCode::semicolon, QKeyCode::apostrophe, QKeyCode::grave_accent, QKeyCode::backslash, QKeyCode::z, QKeyCode::x, QKeyCode::c, QKeyCode::v, QKeyCode::b, QKeyCode::n, QKeyCode::m, QKeyCode::comma, QKeyCode::dot, QKeyCode::slash, QKeyCode::asterisk, QKeyCode::spc, QKeyCode::caps_lock, QKeyCode::f1, QKeyCode::f2, QKeyCode::f3, QKeyCode::f4, QKeyCode::f5, QKeyCode::f6, QKeyCode::f7, QKeyCode::f8, QKeyCode::f9, QKeyCode::f10, QKeyCode::num_lock, QKeyCode::scroll_lock, QKeyCode::kp_divide, QKeyCode::kp_multiply, QKeyCode::kp_subtract, QKeyCode::kp_add, QKeyCode::kp_enter, QKeyCode::kp_decimal, QKeyCode::sysrq, QKeyCode::kp_0, QKeyCode::kp_1, QKeyCode::kp_2, QKeyCode::kp_3, QKeyCode::kp_4, QKeyCode::kp_5, QKeyCode::kp_6, QKeyCode::kp_7, QKeyCode::kp_8, QKeyCode::kp_9, QKeyCode::less, QKeyCode::f11, QKeyCode::f12, QKeyCode::print, QKeyCode::home, QKeyCode::pgup, QKeyCode::pgdn, QKeyCode::end, QKeyCode::left, QKeyCode::up, QKeyCode::down, QKeyCode::right, QKeyCode::insert, QKeyCode::delete, QKeyCode::stop, QKeyCode::again, QKeyCode::props, QKeyCode::undo, QKeyCode::front, QKeyCode::copy, QKeyCode::open, QKeyCode::paste, QKeyCode::find, QKeyCode::cut, QKeyCode::lf, QKeyCode::help, QKeyCode::meta_l, QKeyCode::meta_r, QKeyCode::compose, QKeyCode::pause, QKeyCode::ro, QKeyCode::hiragana, QKeyCode::henkan, QKeyCode::yen, QKeyCode::muhenkan, QKeyCode::katakanahiragana, QKeyCode::kp_comma, QKeyCode::kp_equals, QKeyCode::power, QKeyCode::sleep, QKeyCode::wake, QKeyCode::audionext, QKeyCode::audioprev, QKeyCode::audiostop, QKeyCode::audioplay, QKeyCode::audiomute, QKeyCode::volumeup, QKeyCode::volumedown, QKeyCode::mediaselect, QKeyCode::mail, QKeyCode::calculator, QKeyCode::computer, QKeyCode::ac_home, QKeyCode::ac_back, QKeyCode::ac_forward, QKeyCode::ac_refresh, QKeyCode::ac_bookmarks, QKeyCode::lang1, QKeyCode::lang2, QKeyCode::f13, QKeyCode::f14, QKeyCode::f15, QKeyCode::f16, QKeyCode::f17, QKeyCode::f18, QKeyCode::f19, QKeyCode::f20, QKeyCode::f21, QKeyCode::f22, QKeyCode::f23, QKeyCode::f24]

const NAMES: &'static [&'static str] = &["unmapped", "shift", "shift_r", "alt", "alt_r", "ctrl", "ctrl_r", "menu", "esc", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "minus", "equal", "backspace", "tab", "q", "w", "e", "r", "t", "y", "u", "i", "o", "p", "bracket_left", "bracket_right", "ret", "a", "s", "d", "f", "g", "h", "j", "k", "l", "semicolon", "apostrophe", "grave_accent", "backslash", "z", "x", "c", "v", "b", "n", "m", "comma", "dot", "slash", "asterisk", "spc", "caps_lock", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "num_lock", "scroll_lock", "kp_divide", "kp_multiply", "kp_subtract", "kp_add", "kp_enter", "kp_decimal", "sysrq", "kp_0", "kp_1", "kp_2", "kp_3", "kp_4", "kp_5", "kp_6", "kp_7", "kp_8", "kp_9", "less", "f11", "f12", "print", "home", "pgup", "pgdn", "end", "left", "up", "down", "right", "insert", "delete", "stop", "again", "props", "undo", "front", "copy", "open", "paste", "find", "cut", "lf", "help", "meta_l", "meta_r", "compose", "pause", "ro", "hiragana", "henkan", "yen", "muhenkan", "katakanahiragana", "kp_comma", "kp_equals", "power", "sleep", "wake", "audionext", "audioprev", "audiostop", "audioplay", "audiomute", "volumeup", "volumedown", "mediaselect", "mail", "calculator", "computer", "ac_home", "ac_back", "ac_forward", "ac_refresh", "ac_bookmarks", "lang1", "lang2", "f13", "f14", "f15", "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", "f24"]

impl Enum for VncVencryptSubAuth

fn discriminant(&self) -> usize

const COUNT: usize = 9usize

const VARIANTS: &'static [VncVencryptSubAuth] = &[VncVencryptSubAuth::plain, VncVencryptSubAuth::tls_none, VncVencryptSubAuth::x509_none, VncVencryptSubAuth::tls_vnc, VncVencryptSubAuth::x509_vnc, VncVencryptSubAuth::tls_plain, VncVencryptSubAuth::x509_plain, VncVencryptSubAuth::tls_sasl, VncVencryptSubAuth::x509_sasl]

const NAMES: &'static [&'static str] = &["plain", "tls-none", "x509-none", "tls-vnc", "x509-vnc", "tls-plain", "x509-plain", "tls-sasl", "x509-sasl"]

impl Enum for TpmType

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [TpmType] = &[TpmType::passthrough, TpmType::emulator]

const NAMES: &'static [&'static str] = &["passthrough", "emulator"]

impl Enum for StatsType

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [StatsType] = &[StatsType::cumulative, StatsType::instant, StatsType::peak, StatsType::linear_histogram, StatsType::log2_histogram]

const NAMES: &'static [&'static str] = &["cumulative", "instant", "peak", "linear-histogram", "log2-histogram"]

impl Enum for SetPasswordAction

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [SetPasswordAction] = &[SetPasswordAction::keep, SetPasswordAction::fail, SetPasswordAction::disconnect]

const NAMES: &'static [&'static str] = &["keep", "fail", "disconnect"]

impl Enum for InputButton

fn discriminant(&self) -> usize

const COUNT: usize = 9usize

const VARIANTS: &'static [InputButton] = &[InputButton::left, InputButton::middle, InputButton::right, InputButton::wheel_up, InputButton::wheel_down, InputButton::side, InputButton::extra, InputButton::wheel_left, InputButton::wheel_right]

const NAMES: &'static [&'static str] = &["left", "middle", "right", "wheel-up", "wheel-down", "side", "extra", "wheel-left", "wheel-right"]

impl Enum for QCryptodevBackendType

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [QCryptodevBackendType] = &[QCryptodevBackendType::builtin, QCryptodevBackendType::vhost_user, QCryptodevBackendType::lkcf]

const NAMES: &'static [&'static str] = &["builtin", "vhost-user", "lkcf"]

impl Enum for QCryptoCipherAlgorithm

fn discriminant(&self) -> usize

const COUNT: usize = 12usize

const VARIANTS: &'static [QCryptoCipherAlgorithm] = &[QCryptoCipherAlgorithm::aes_128, QCryptoCipherAlgorithm::aes_192, QCryptoCipherAlgorithm::aes_256, QCryptoCipherAlgorithm::des, QCryptoCipherAlgorithm::_3des, QCryptoCipherAlgorithm::cast5_128, QCryptoCipherAlgorithm::serpent_128, QCryptoCipherAlgorithm::serpent_192, QCryptoCipherAlgorithm::serpent_256, QCryptoCipherAlgorithm::twofish_128, QCryptoCipherAlgorithm::twofish_192, QCryptoCipherAlgorithm::twofish_256]

const NAMES: &'static [&'static str] = &["aes-128", "aes-192", "aes-256", "des", "3des", "cast5-128", "serpent-128", "serpent-192", "serpent-256", "twofish-128", "twofish-192", "twofish-256"]

impl Enum for BlockdevDriver

fn discriminant(&self) -> usize

const COUNT: usize = 47usize

const VARIANTS: &'static [BlockdevDriver] = &[BlockdevDriver::blkdebug, BlockdevDriver::blklogwrites, BlockdevDriver::blkreplay, BlockdevDriver::blkverify, BlockdevDriver::bochs, BlockdevDriver::cloop, BlockdevDriver::compress, BlockdevDriver::copy_before_write, BlockdevDriver::copy_on_read, BlockdevDriver::dmg, BlockdevDriver::file, BlockdevDriver::snapshot_access, BlockdevDriver::ftp, BlockdevDriver::ftps, BlockdevDriver::gluster, BlockdevDriver::host_cdrom, BlockdevDriver::host_device, BlockdevDriver::http, BlockdevDriver::https, BlockdevDriver::io_uring, BlockdevDriver::iscsi, BlockdevDriver::luks, BlockdevDriver::nbd, BlockdevDriver::nfs, BlockdevDriver::null_aio, BlockdevDriver::null_co, BlockdevDriver::nvme, BlockdevDriver::nvme_io_uring, BlockdevDriver::parallels, BlockdevDriver::preallocate, BlockdevDriver::qcow, BlockdevDriver::qcow2, BlockdevDriver::qed, BlockdevDriver::quorum, BlockdevDriver::raw, BlockdevDriver::rbd, BlockdevDriver::replication, BlockdevDriver::ssh, BlockdevDriver::throttle, BlockdevDriver::vdi, BlockdevDriver::vhdx, BlockdevDriver::virtio_blk_vfio_pci, BlockdevDriver::virtio_blk_vhost_user, BlockdevDriver::virtio_blk_vhost_vdpa, BlockdevDriver::vmdk, BlockdevDriver::vpc, BlockdevDriver::vvfat]

const NAMES: &'static [&'static str] = &["blkdebug", "blklogwrites", "blkreplay", "blkverify", "bochs", "cloop", "compress", "copy-before-write", "copy-on-read", "dmg", "file", "snapshot-access", "ftp", "ftps", "gluster", "host_cdrom", "host_device", "http", "https", "io_uring", "iscsi", "luks", "nbd", "nfs", "null-aio", "null-co", "nvme", "nvme-io_uring", "parallels", "preallocate", "qcow", "qcow2", "qed", "quorum", "raw", "rbd", "replication", "ssh", "throttle", "vdi", "vhdx", "virtio-blk-vfio-pci", "virtio-blk-vhost-user", "virtio-blk-vhost-vdpa", "vmdk", "vpc", "vvfat"]

impl Enum for LostTickPolicy

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [LostTickPolicy] = &[LostTickPolicy::discard, LostTickPolicy::delay, LostTickPolicy::slew]

const NAMES: &'static [&'static str] = &["discard", "delay", "slew"]

impl Enum for BlockdevQcow2Version

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [BlockdevQcow2Version] = &[BlockdevQcow2Version::v2, BlockdevQcow2Version::v3]

const NAMES: &'static [&'static str] = &["v2", "v3"]

impl Enum for BlockErrorAction

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [BlockErrorAction] = &[BlockErrorAction::ignore, BlockErrorAction::report, BlockErrorAction::stop]

const NAMES: &'static [&'static str] = &["ignore", "report", "stop"]

impl Enum for BiosAtaTranslation

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [BiosAtaTranslation] = &[BiosAtaTranslation::auto, BiosAtaTranslation::none, BiosAtaTranslation::lba, BiosAtaTranslation::large, BiosAtaTranslation::rechs]

const NAMES: &'static [&'static str] = &["auto", "none", "lba", "large", "rechs"]

impl Enum for JSONType

fn discriminant(&self) -> usize

const COUNT: usize = 8usize

const VARIANTS: &'static [JSONType] = &[JSONType::string, JSONType::number, JSONType::int, JSONType::boolean, JSONType::null, JSONType::object, JSONType::array, JSONType::value]

const NAMES: &'static [&'static str] = &["string", "number", "int", "boolean", "null", "object", "array", "value"]

impl Enum for HmatLBDataType

fn discriminant(&self) -> usize

const COUNT: usize = 6usize

const VARIANTS: &'static [HmatLBDataType] = &[HmatLBDataType::access_latency, HmatLBDataType::read_latency, HmatLBDataType::write_latency, HmatLBDataType::access_bandwidth, HmatLBDataType::read_bandwidth, HmatLBDataType::write_bandwidth]

const NAMES: &'static [&'static str] = &["access-latency", "read-latency", "write-latency", "access-bandwidth", "read-bandwidth", "write-bandwidth"]

impl Enum for InputEventKind

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [InputEventKind] = &[InputEventKind::key, InputEventKind::btn, InputEventKind::rel, InputEventKind::abs]

const NAMES: &'static [&'static str] = &["key", "btn", "rel", "abs"]

impl Enum for XDbgBlockGraphNodeType

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [XDbgBlockGraphNodeType] = &[XDbgBlockGraphNodeType::block_backend, XDbgBlockGraphNodeType::block_job, XDbgBlockGraphNodeType::block_driver]

const NAMES: &'static [&'static str] = &["block-backend", "block-job", "block-driver"]

impl Enum for MigrationCapability

fn discriminant(&self) -> usize

const COUNT: usize = 21usize

const VARIANTS: &'static [MigrationCapability] = &[MigrationCapability::xbzrle, MigrationCapability::rdma_pin_all, MigrationCapability::auto_converge, MigrationCapability::zero_blocks, MigrationCapability::compress, MigrationCapability::events, MigrationCapability::postcopy_ram, MigrationCapability::x_colo, MigrationCapability::release_ram, MigrationCapability::block, MigrationCapability::return_path, MigrationCapability::pause_before_switchover, MigrationCapability::multifd, MigrationCapability::dirty_bitmaps, MigrationCapability::postcopy_blocktime, MigrationCapability::late_block_activate, MigrationCapability::x_ignore_shared, MigrationCapability::validate_uuid, MigrationCapability::background_snapshot, MigrationCapability::zero_copy_send, MigrationCapability::postcopy_preempt]

const NAMES: &'static [&'static str] = &["xbzrle", "rdma-pin-all", "auto-converge", "zero-blocks", "compress", "events", "postcopy-ram", "x-colo", "release-ram", "block", "return-path", "pause-before-switchover", "multifd", "dirty-bitmaps", "postcopy-blocktime", "late-block-activate", "x-ignore-shared", "validate-uuid", "background-snapshot", "zero-copy-send", "postcopy-preempt"]

impl Enum for BlockdevChangeReadOnlyMode

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [BlockdevChangeReadOnlyMode] = &[BlockdevChangeReadOnlyMode::retain, BlockdevChangeReadOnlyMode::read_only, BlockdevChangeReadOnlyMode::read_write]

const NAMES: &'static [&'static str] = &["retain", "read-only", "read-write"]

impl Enum for BlockdevAioOptions

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [BlockdevAioOptions] = &[BlockdevAioOptions::threads, BlockdevAioOptions::native, BlockdevAioOptions::io_uring]

const NAMES: &'static [&'static str] = &["threads", "native", "io_uring"]

impl Enum for BlockdevVpcSubformat

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [BlockdevVpcSubformat] = &[BlockdevVpcSubformat::dynamic, BlockdevVpcSubformat::fixed]

const NAMES: &'static [&'static str] = &["dynamic", "fixed"]

impl Enum for PCIELinkSpeed

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [PCIELinkSpeed] = &[PCIELinkSpeed::_2_5, PCIELinkSpeed::_5, PCIELinkSpeed::_8, PCIELinkSpeed::_16]

const NAMES: &'static [&'static str] = &["2_5", "5", "8", "16"]

impl Enum for NetFilterDirection

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [NetFilterDirection] = &[NetFilterDirection::all, NetFilterDirection::rx, NetFilterDirection::tx]

const NAMES: &'static [&'static str] = &["all", "rx", "tx"]

impl Enum for BlockdevQcow2EncryptionFormat

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [BlockdevQcow2EncryptionFormat] = &[BlockdevQcow2EncryptionFormat::aes, BlockdevQcow2EncryptionFormat::luks]

const NAMES: &'static [&'static str] = &["aes", "luks"]

impl Enum for MirrorCopyMode

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [MirrorCopyMode] = &[MirrorCopyMode::background, MirrorCopyMode::write_blocking]

const NAMES: &'static [&'static str] = &["background", "write-blocking"]

impl Enum for RockerPortDuplex

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [RockerPortDuplex] = &[RockerPortDuplex::half, RockerPortDuplex::full]

const NAMES: &'static [&'static str] = &["half", "full"]

impl Enum for FloppyDriveType

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [FloppyDriveType] = &[FloppyDriveType::_144, FloppyDriveType::_288, FloppyDriveType::_120, FloppyDriveType::none, FloppyDriveType::auto]

const NAMES: &'static [&'static str] = &["144", "288", "120", "none", "auto"]

impl Enum for HmatCacheWritePolicy

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [HmatCacheWritePolicy] = &[HmatCacheWritePolicy::none, HmatCacheWritePolicy::write_back, HmatCacheWritePolicy::write_through]

const NAMES: &'static [&'static str] = &["none", "write-back", "write-through"]

impl Enum for QCryptoRSAPaddingAlgorithm

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [QCryptoRSAPaddingAlgorithm] = &[QCryptoRSAPaddingAlgorithm::raw, QCryptoRSAPaddingAlgorithm::pkcs1]

const NAMES: &'static [&'static str] = &["raw", "pkcs1"]

impl Enum for MemoryFailureRecipient

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [MemoryFailureRecipient] = &[MemoryFailureRecipient::hypervisor, MemoryFailureRecipient::guest]

const NAMES: &'static [&'static str] = &["hypervisor", "guest"]

impl Enum for X86CPURegister32

fn discriminant(&self) -> usize

const COUNT: usize = 8usize

const VARIANTS: &'static [X86CPURegister32] = &[X86CPURegister32::EAX, X86CPURegister32::EBX, X86CPURegister32::ECX, X86CPURegister32::EDX, X86CPURegister32::ESP, X86CPURegister32::EBP, X86CPURegister32::ESI, X86CPURegister32::EDI]

const NAMES: &'static [&'static str] = &["EAX", "EBX", "ECX", "EDX", "ESP", "EBP", "ESI", "EDI"]

impl Enum for QuorumOpType

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [QuorumOpType] = &[QuorumOpType::read, QuorumOpType::write, QuorumOpType::flush]

const NAMES: &'static [&'static str] = &["read", "write", "flush"]

impl Enum for RockerPortAutoneg

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [RockerPortAutoneg] = &[RockerPortAutoneg::off, RockerPortAutoneg::on]

const NAMES: &'static [&'static str] = &["off", "on"]

impl Enum for NetfilterInsert

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [NetfilterInsert] = &[NetfilterInsert::before, NetfilterInsert::behind]

const NAMES: &'static [&'static str] = &["before", "behind"]

impl Enum for COLOMode

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [COLOMode] = &[COLOMode::none, COLOMode::primary, COLOMode::secondary]

const NAMES: &'static [&'static str] = &["none", "primary", "secondary"]

impl Enum for RunState

fn discriminant(&self) -> usize

const COUNT: usize = 16usize

const VARIANTS: &'static [RunState] = &[RunState::debug, RunState::inmigrate, RunState::internal_error, RunState::io_error, RunState::paused, RunState::postmigrate, RunState::prelaunch, RunState::finish_migrate, RunState::restore_vm, RunState::running, RunState::save_vm, RunState::shutdown, RunState::suspended, RunState::watchdog, RunState::guest_panicked, RunState::colo]

const NAMES: &'static [&'static str] = &["debug", "inmigrate", "internal-error", "io-error", "paused", "postmigrate", "prelaunch", "finish-migrate", "restore-vm", "running", "save-vm", "shutdown", "suspended", "watchdog", "guest-panicked", "colo"]

impl Enum for NumaOptionsType

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [NumaOptionsType] = &[NumaOptionsType::node, NumaOptionsType::dist, NumaOptionsType::cpu, NumaOptionsType::hmat_lb, NumaOptionsType::hmat_cache]

const NAMES: &'static [&'static str] = &["node", "dist", "cpu", "hmat-lb", "hmat-cache"]

impl Enum for ObjectType

fn discriminant(&self) -> usize

const COUNT: usize = 44usize

const VARIANTS: &'static [ObjectType] = &[ObjectType::authz_list, ObjectType::authz_listfile, ObjectType::authz_pam, ObjectType::authz_simple, ObjectType::can_bus, ObjectType::can_host_socketcan, ObjectType::colo_compare, ObjectType::cryptodev_backend, ObjectType::cryptodev_backend_builtin, ObjectType::cryptodev_backend_lkcf, ObjectType::cryptodev_vhost_user, ObjectType::dbus_vmstate, ObjectType::filter_buffer, ObjectType::filter_dump, ObjectType::filter_mirror, ObjectType::filter_redirector, ObjectType::filter_replay, ObjectType::filter_rewriter, ObjectType::input_barrier, ObjectType::input_linux, ObjectType::iothread, ObjectType::main_loop, ObjectType::memory_backend_epc, ObjectType::memory_backend_file, ObjectType::memory_backend_memfd, ObjectType::memory_backend_ram, ObjectType::pef_guest, ObjectType::pr_manager_helper, ObjectType::qtest, ObjectType::rng_builtin, ObjectType::rng_egd, ObjectType::rng_random, ObjectType::secret, ObjectType::secret_keyring, ObjectType::sev_guest, ObjectType::thread_context, ObjectType::s390_pv_guest, ObjectType::throttle_group, ObjectType::tls_creds_anon, ObjectType::tls_creds_psk, ObjectType::tls_creds_x509, ObjectType::tls_cipher_suites, ObjectType::x_remote_object, ObjectType::x_vfio_user_server]

const NAMES: &'static [&'static str] = &["authz-list", "authz-listfile", "authz-pam", "authz-simple", "can-bus", "can-host-socketcan", "colo-compare", "cryptodev-backend", "cryptodev-backend-builtin", "cryptodev-backend-lkcf", "cryptodev-vhost-user", "dbus-vmstate", "filter-buffer", "filter-dump", "filter-mirror", "filter-redirector", "filter-replay", "filter-rewriter", "input-barrier", "input-linux", "iothread", "main-loop", "memory-backend-epc", "memory-backend-file", "memory-backend-memfd", "memory-backend-ram", "pef-guest", "pr-manager-helper", "qtest", "rng-builtin", "rng-egd", "rng-random", "secret", "secret_keyring", "sev-guest", "thread-context", "s390-pv-guest", "throttle-group", "tls-creds-anon", "tls-creds-psk", "tls-creds-x509", "tls-cipher-suites", "x-remote-object", "x-vfio-user-server"]

impl Enum for EvtchnPortType

fn discriminant(&self) -> usize

const COUNT: usize = 6usize

const VARIANTS: &'static [EvtchnPortType] = &[EvtchnPortType::closed, EvtchnPortType::unbound, EvtchnPortType::interdomain, EvtchnPortType::pirq, EvtchnPortType::virq, EvtchnPortType::ipi]

const NAMES: &'static [&'static str] = &["closed", "unbound", "interdomain", "pirq", "virq", "ipi"]

impl Enum for BlockPermission

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [BlockPermission] = &[BlockPermission::consistent_read, BlockPermission::write, BlockPermission::write_unchanged, BlockPermission::resize]

const NAMES: &'static [&'static str] = &["consistent-read", "write", "write-unchanged", "resize"]

impl Enum for RbdAuthMode

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [RbdAuthMode] = &[RbdAuthMode::cephx, RbdAuthMode::none]

const NAMES: &'static [&'static str] = &["cephx", "none"]

impl Enum for Qcow2CompressionType

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [Qcow2CompressionType] = &[Qcow2CompressionType::zlib, Qcow2CompressionType::zstd]

const NAMES: &'static [&'static str] = &["zlib", "zstd"]

impl Enum for SevState

fn discriminant(&self) -> usize

const COUNT: usize = 6usize

const VARIANTS: &'static [SevState] = &[SevState::uninit, SevState::launch_update, SevState::launch_secret, SevState::running, SevState::send_update, SevState::receive_update]

const NAMES: &'static [&'static str] = &["uninit", "launch-update", "launch-secret", "running", "send-update", "receive-update"]

impl Enum for QCryptoBlockFormat

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [QCryptoBlockFormat] = &[QCryptoBlockFormat::qcow, QCryptoBlockFormat::luks]

const NAMES: &'static [&'static str] = &["qcow", "luks"]

impl Enum for COLOMessage

fn discriminant(&self) -> usize

const COUNT: usize = 7usize

const VARIANTS: &'static [COLOMessage] = &[COLOMessage::checkpoint_ready, COLOMessage::checkpoint_request, COLOMessage::checkpoint_reply, COLOMessage::vmstate_send, COLOMessage::vmstate_size, COLOMessage::vmstate_received, COLOMessage::vmstate_loaded]

const NAMES: &'static [&'static str] = &["checkpoint-ready", "checkpoint-request", "checkpoint-reply", "vmstate-send", "vmstate-size", "vmstate-received", "vmstate-loaded"]

impl Enum for SpiceQueryMouseMode

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [SpiceQueryMouseMode] = &[SpiceQueryMouseMode::client, SpiceQueryMouseMode::server, SpiceQueryMouseMode::unknown]

const NAMES: &'static [&'static str] = &["client", "server", "unknown"]

impl Enum for MultiFDCompression

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [MultiFDCompression] = &[MultiFDCompression::none, MultiFDCompression::zlib, MultiFDCompression::zstd]

const NAMES: &'static [&'static str] = &["none", "zlib", "zstd"]

impl Enum for SysEmuTarget

fn discriminant(&self) -> usize

const COUNT: usize = 31usize

const VARIANTS: &'static [SysEmuTarget] = &[SysEmuTarget::aarch64, SysEmuTarget::alpha, SysEmuTarget::arm, SysEmuTarget::avr, SysEmuTarget::cris, SysEmuTarget::hppa, SysEmuTarget::i386, SysEmuTarget::loongarch64, SysEmuTarget::m68k, SysEmuTarget::microblaze, SysEmuTarget::microblazeel, SysEmuTarget::mips, SysEmuTarget::mips64, SysEmuTarget::mips64el, SysEmuTarget::mipsel, SysEmuTarget::nios2, SysEmuTarget::or1k, SysEmuTarget::ppc, SysEmuTarget::ppc64, SysEmuTarget::riscv32, SysEmuTarget::riscv64, SysEmuTarget::rx, SysEmuTarget::s390x, SysEmuTarget::sh4, SysEmuTarget::sh4eb, SysEmuTarget::sparc, SysEmuTarget::sparc64, SysEmuTarget::tricore, SysEmuTarget::x86_64, SysEmuTarget::xtensa, SysEmuTarget::xtensaeb]

const NAMES: &'static [&'static str] = &["aarch64", "alpha", "arm", "avr", "cris", "hppa", "i386", "loongarch64", "m68k", "microblaze", "microblazeel", "mips", "mips64", "mips64el", "mipsel", "nios2", "or1k", "ppc", "ppc64", "riscv32", "riscv64", "rx", "s390x", "sh4", "sh4eb", "sparc", "sparc64", "tricore", "x86_64", "xtensa", "xtensaeb"]

impl Enum for ACPISlotType

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [ACPISlotType] = &[ACPISlotType::DIMM, ACPISlotType::CPU]

const NAMES: &'static [&'static str] = &["DIMM", "CPU"]

impl Enum for StatsProvider

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [StatsProvider] = &[StatsProvider::kvm, StatsProvider::cryptodev]

const NAMES: &'static [&'static str] = &["kvm", "cryptodev"]

impl Enum for DisplayUpdateType

fn discriminant(&self) -> usize

const COUNT: usize = 1usize

const VARIANTS: &'static [DisplayUpdateType] = &[DisplayUpdateType::vnc]

const NAMES: &'static [&'static str] = &["vnc"]

impl Enum for BlockdevQcowEncryptionFormat

fn discriminant(&self) -> usize

const COUNT: usize = 1usize

const VARIANTS: &'static [BlockdevQcowEncryptionFormat] = &[BlockdevQcowEncryptionFormat::aes]

const NAMES: &'static [&'static str] = &["aes"]

impl Enum for PreallocMode

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [PreallocMode] = &[PreallocMode::off, PreallocMode::metadata, PreallocMode::falloc, PreallocMode::full]

const NAMES: &'static [&'static str] = &["off", "metadata", "falloc", "full"]

impl Enum for CxlCorErrorType

fn discriminant(&self) -> usize

const COUNT: usize = 7usize

const VARIANTS: &'static [CxlCorErrorType] = &[CxlCorErrorType::cache_data_ecc, CxlCorErrorType::mem_data_ecc, CxlCorErrorType::crc_threshold, CxlCorErrorType::retry_threshold, CxlCorErrorType::cache_poison_received, CxlCorErrorType::mem_poison_received, CxlCorErrorType::physical]

const NAMES: &'static [&'static str] = &["cache-data-ecc", "mem-data-ecc", "crc-threshold", "retry-threshold", "cache-poison-received", "mem-poison-received", "physical"]

impl Enum for NotifyVmexitOption

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [NotifyVmexitOption] = &[NotifyVmexitOption::run, NotifyVmexitOption::internal_error, NotifyVmexitOption::disable]

const NAMES: &'static [&'static str] = &["run", "internal-error", "disable"]

impl Enum for QCryptoTLSCredsEndpoint

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [QCryptoTLSCredsEndpoint] = &[QCryptoTLSCredsEndpoint::client, QCryptoTLSCredsEndpoint::server]

const NAMES: &'static [&'static str] = &["client", "server"]

impl Enum for QCryptoSecretFormat

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [QCryptoSecretFormat] = &[QCryptoSecretFormat::raw, QCryptoSecretFormat::base64]

const NAMES: &'static [&'static str] = &["raw", "base64"]

impl Enum for JobVerb

fn discriminant(&self) -> usize

const COUNT: usize = 7usize

const VARIANTS: &'static [JobVerb] = &[JobVerb::cancel, JobVerb::pause, JobVerb::resume, JobVerb::set_speed, JobVerb::complete, JobVerb::dismiss, JobVerb::finalize]

const NAMES: &'static [&'static str] = &["cancel", "pause", "resume", "set-speed", "complete", "dismiss", "finalize"]

impl Enum for HostMemPolicy

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [HostMemPolicy] = &[HostMemPolicy::default, HostMemPolicy::preferred, HostMemPolicy::bind, HostMemPolicy::interleave]

const NAMES: &'static [&'static str] = &["default", "preferred", "bind", "interleave"]

impl Enum for MirrorSyncMode

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [MirrorSyncMode] = &[MirrorSyncMode::top, MirrorSyncMode::full, MirrorSyncMode::none, MirrorSyncMode::incremental, MirrorSyncMode::bitmap]

const NAMES: &'static [&'static str] = &["top", "full", "none", "incremental", "bitmap"]

impl Enum for BlockdevOnError

fn discriminant(&self) -> usize

const COUNT: usize = 5usize

const VARIANTS: &'static [BlockdevOnError] = &[BlockdevOnError::report, BlockdevOnError::ignore, BlockdevOnError::enospc, BlockdevOnError::stop, BlockdevOnError::auto]

const NAMES: &'static [&'static str] = &["report", "ignore", "enospc", "stop", "auto"]

impl Enum for QMPCapability

fn discriminant(&self) -> usize

const COUNT: usize = 1usize

const VARIANTS: &'static [QMPCapability] = &[QMPCapability::oob]

const NAMES: &'static [&'static str] = &["oob"]

impl Enum for BlockExportType

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [BlockExportType] = &[BlockExportType::nbd, BlockExportType::vhost_user_blk, BlockExportType::fuse, BlockExportType::vduse_blk]

const NAMES: &'static [&'static str] = &["nbd", "vhost-user-blk", "fuse", "vduse-blk"]

impl Enum for SshHostKeyCheckHashType

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [SshHostKeyCheckHashType] = &[SshHostKeyCheckHashType::md5, SshHostKeyCheckHashType::sha1, SshHostKeyCheckHashType::sha256]

const NAMES: &'static [&'static str] = &["md5", "sha1", "sha256"]

impl Enum for VncPrimaryAuth

fn discriminant(&self) -> usize

const COUNT: usize = 9usize

const VARIANTS: &'static [VncPrimaryAuth] = &[VncPrimaryAuth::none, VncPrimaryAuth::vnc, VncPrimaryAuth::ra2, VncPrimaryAuth::ra2ne, VncPrimaryAuth::tight, VncPrimaryAuth::ultra, VncPrimaryAuth::tls, VncPrimaryAuth::vencrypt, VncPrimaryAuth::sasl]

const NAMES: &'static [&'static str] = &["none", "vnc", "ra2", "ra2ne", "tight", "ultra", "tls", "vencrypt", "sasl"]

impl Enum for OnCbwError

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [OnCbwError] = &[OnCbwError::break_guest_write, OnCbwError::break_snapshot]

const NAMES: &'static [&'static str] = &["break-guest-write", "break-snapshot"]

impl Enum for NewImageMode

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [NewImageMode] = &[NewImageMode::existing, NewImageMode::absolute_paths]

const NAMES: &'static [&'static str] = &["existing", "absolute-paths"]

impl Enum for AudiodevDriver

fn discriminant(&self) -> usize

const COUNT: usize = 12usize

const VARIANTS: &'static [AudiodevDriver] = &[AudiodevDriver::none, AudiodevDriver::alsa, AudiodevDriver::coreaudio, AudiodevDriver::dbus, AudiodevDriver::dsound, AudiodevDriver::jack, AudiodevDriver::oss, AudiodevDriver::pa, AudiodevDriver::sdl, AudiodevDriver::sndio, AudiodevDriver::spice, AudiodevDriver::wav]

const NAMES: &'static [&'static str] = &["none", "alsa", "coreaudio", "dbus", "dsound", "jack", "oss", "pa", "sdl", "sndio", "spice", "wav"]

impl Enum for BlockdevDiscardOptions

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [BlockdevDiscardOptions] = &[BlockdevDiscardOptions::ignore, BlockdevDiscardOptions::unmap]

const NAMES: &'static [&'static str] = &["ignore", "unmap"]

impl Enum for IscsiHeaderDigest

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [IscsiHeaderDigest] = &[IscsiHeaderDigest::crc32c, IscsiHeaderDigest::none, IscsiHeaderDigest::crc32c_none, IscsiHeaderDigest::none_crc32c]

const NAMES: &'static [&'static str] = &["crc32c", "none", "crc32c-none", "none-crc32c"]

impl Enum for FuseExportAllowOther

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [FuseExportAllowOther] = &[FuseExportAllowOther::off, FuseExportAllowOther::on, FuseExportAllowOther::auto]

const NAMES: &'static [&'static str] = &["off", "on", "auto"]

impl Enum for QuorumReadPattern

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [QuorumReadPattern] = &[QuorumReadPattern::quorum, QuorumReadPattern::fifo]

const NAMES: &'static [&'static str] = &["quorum", "fifo"]

impl Enum for IoOperationType

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [IoOperationType] = &[IoOperationType::read, IoOperationType::write]

const NAMES: &'static [&'static str] = &["read", "write"]

impl Enum for CompatPolicyOutput

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [CompatPolicyOutput] = &[CompatPolicyOutput::accept, CompatPolicyOutput::hide]

const NAMES: &'static [&'static str] = &["accept", "hide"]

impl Enum for MemoryFailureAction

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [MemoryFailureAction] = &[MemoryFailureAction::ignore, MemoryFailureAction::inject, MemoryFailureAction::fatal, MemoryFailureAction::reset]

const NAMES: &'static [&'static str] = &["ignore", "inject", "fatal", "reset"]

impl Enum for StatsTarget

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [StatsTarget] = &[StatsTarget::vm, StatsTarget::vcpu, StatsTarget::cryptodev]

const NAMES: &'static [&'static str] = &["vm", "vcpu", "cryptodev"]

impl Enum for NetClientDriver

fn discriminant(&self) -> usize

const COUNT: usize = 17usize

const VARIANTS: &'static [NetClientDriver] = &[NetClientDriver::none, NetClientDriver::nic, NetClientDriver::user, NetClientDriver::tap, NetClientDriver::l2tpv3, NetClientDriver::socket, NetClientDriver::stream, NetClientDriver::dgram, NetClientDriver::vde, NetClientDriver::bridge, NetClientDriver::hubport, NetClientDriver::netmap, NetClientDriver::vhost_user, NetClientDriver::vhost_vdpa, NetClientDriver::vmnet_host, NetClientDriver::vmnet_shared, NetClientDriver::vmnet_bridged]

const NAMES: &'static [&'static str] = &["none", "nic", "user", "tap", "l2tpv3", "socket", "stream", "dgram", "vde", "bridge", "hubport", "netmap", "vhost-user", "vhost-vdpa", "vmnet-host", "vmnet-shared", "vmnet-bridged"]

impl Enum for SshHostKeyCheckMode

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [SshHostKeyCheckMode] = &[SshHostKeyCheckMode::none, SshHostKeyCheckMode::hash, SshHostKeyCheckMode::known_hosts]

const NAMES: &'static [&'static str] = &["none", "hash", "known_hosts"]

impl Enum for PCIELinkWidth

fn discriminant(&self) -> usize

const COUNT: usize = 7usize

const VARIANTS: &'static [PCIELinkWidth] = &[PCIELinkWidth::_1, PCIELinkWidth::_2, PCIELinkWidth::_4, PCIELinkWidth::_8, PCIELinkWidth::_12, PCIELinkWidth::_16, PCIELinkWidth::_32]

const NAMES: &'static [&'static str] = &["1", "2", "4", "8", "12", "16", "32"]

impl Enum for ActionCompletionMode

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [ActionCompletionMode] = &[ActionCompletionMode::individual, ActionCompletionMode::grouped]

const NAMES: &'static [&'static str] = &["individual", "grouped"]

impl Enum for DisplayProtocol

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [DisplayProtocol] = &[DisplayProtocol::vnc, DisplayProtocol::spice]

const NAMES: &'static [&'static str] = &["vnc", "spice"]

impl Enum for QCryptoIVGenAlgorithm

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [QCryptoIVGenAlgorithm] = &[QCryptoIVGenAlgorithm::plain, QCryptoIVGenAlgorithm::plain64, QCryptoIVGenAlgorithm::essiv]

const NAMES: &'static [&'static str] = &["plain", "plain64", "essiv"]

impl Enum for DumpStatus

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [DumpStatus] = &[DumpStatus::none, DumpStatus::active, DumpStatus::completed, DumpStatus::failed]

const NAMES: &'static [&'static str] = &["none", "active", "completed", "failed"]

impl Enum for OnOffAuto

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [OnOffAuto] = &[OnOffAuto::auto, OnOffAuto::on, OnOffAuto::off]

const NAMES: &'static [&'static str] = &["auto", "on", "off"]

impl Enum for WatchdogAction

fn discriminant(&self) -> usize

const COUNT: usize = 7usize

const VARIANTS: &'static [WatchdogAction] = &[WatchdogAction::reset, WatchdogAction::shutdown, WatchdogAction::poweroff, WatchdogAction::pause, WatchdogAction::debug, WatchdogAction::none, WatchdogAction::inject_nmi]

const NAMES: &'static [&'static str] = &["reset", "shutdown", "poweroff", "pause", "debug", "none", "inject-nmi"]

impl Enum for GuestMemoryBlockResponseType

fn discriminant(&self) -> usize

const COUNT: usize = 4usize

const VARIANTS: &'static [GuestMemoryBlockResponseType] = &[GuestMemoryBlockResponseType::success, GuestMemoryBlockResponseType::not_found, GuestMemoryBlockResponseType::operation_not_supported, GuestMemoryBlockResponseType::operation_failed]

const NAMES: &'static [&'static str] = &["success", "not-found", "operation-not-supported", "operation-failed"]

impl Enum for GuestDiskBusType

fn discriminant(&self) -> usize

const COUNT: usize = 20usize

const VARIANTS: &'static [GuestDiskBusType] = &[GuestDiskBusType::ide, GuestDiskBusType::fdc, GuestDiskBusType::scsi, GuestDiskBusType::virtio, GuestDiskBusType::xen, GuestDiskBusType::usb, GuestDiskBusType::uml, GuestDiskBusType::sata, GuestDiskBusType::sd, GuestDiskBusType::unknown, GuestDiskBusType::ieee1394, GuestDiskBusType::ssa, GuestDiskBusType::fibre, GuestDiskBusType::raid, GuestDiskBusType::iscsi, GuestDiskBusType::sas, GuestDiskBusType::mmc, GuestDiskBusType::virtual_, GuestDiskBusType::file_backed_virtual, GuestDiskBusType::nvme]

const NAMES: &'static [&'static str] = &["ide", "fdc", "scsi", "virtio", "xen", "usb", "uml", "sata", "sd", "unknown", "ieee1394", "ssa", "fibre", "raid", "iscsi", "sas", "mmc", "virtual", "file-backed-virtual", "nvme"]

impl Enum for QGASeek

fn discriminant(&self) -> usize

const COUNT: usize = 3usize

const VARIANTS: &'static [QGASeek] = &[QGASeek::set, QGASeek::cur, QGASeek::end]

const NAMES: &'static [&'static str] = &["set", "cur", "end"]

impl Enum for GuestCpuStatsType

fn discriminant(&self) -> usize

const COUNT: usize = 1usize

const VARIANTS: &'static [GuestCpuStatsType] = &[GuestCpuStatsType::linux]

const NAMES: &'static [&'static str] = &["linux"]

impl Enum for GuestFsfreezeStatus

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [GuestFsfreezeStatus] = &[GuestFsfreezeStatus::thawed, GuestFsfreezeStatus::frozen]

const NAMES: &'static [&'static str] = &["thawed", "frozen"]

impl Enum for GuestIpAddressType

fn discriminant(&self) -> usize

const COUNT: usize = 2usize

const VARIANTS: &'static [GuestIpAddressType] = &[GuestIpAddressType::ipv4, GuestIpAddressType::ipv6]

const NAMES: &'static [&'static str] = &["ipv4", "ipv6"]

impl Enum for GuestDeviceType

fn discriminant(&self) -> usize

const COUNT: usize = 1usize

const VARIANTS: &'static [GuestDeviceType] = &[GuestDeviceType::pci]

const NAMES: &'static [&'static str] = &["pci"]

Implementors