vendor/sysinfo/src/serde.rs - toolchain/rustc - Git at Google

 // Take a look at the license at the top of the repository in the LICENSE file.

 use crate::common::PidExt;
 use crate::{
     ComponentExt, CpuExt, DiskExt, DiskKind, DiskUsage, MacAddr, NetworkExt, NetworksExt,
     ProcessExt, ProcessStatus, Signal, SystemExt, UserExt,
 };
 use serde::{ser::SerializeStruct, Serialize, Serializer};
 use std::ops::Deref;

 impl Serialize for crate::Disk {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         let mut state = serializer.serialize_struct("Disk", 7)?;

         state.serialize_field("DiskKind", &self.kind())?;
         if let Some(s) = self.name().to_str() {
             state.serialize_field("name", s)?;
         }
         state.serialize_field("file_system", &self.file_system())?;
         state.serialize_field("mount_point", &self.mount_point())?;
         state.serialize_field("total_space", &self.total_space())?;
         state.serialize_field("available_space", &self.available_space())?;
         state.serialize_field("is_removable", &self.is_removable())?;

         state.end()
     }
 }

 impl Serialize for crate::Process {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         let mut state = serializer.serialize_struct("Process", 18)?;

         state.serialize_field("name", &self.name())?;
         state.serialize_field("cmd", &self.cmd())?;
         state.serialize_field("exe", &self.exe())?;
         state.serialize_field("pid", &self.pid().as_u32())?;
         state.serialize_field("environ", &self.environ())?;
         state.serialize_field("cwd", &self.cwd())?;
         state.serialize_field("root", &self.root())?;
         state.serialize_field("memory", &self.memory())?;
         state.serialize_field("virtual_memory", &self.virtual_memory())?;
         if let Some(pid) = self.parent() {
             state.serialize_field("parent", &pid.as_u32())?;
         }
         state.serialize_field("status", &self.status())?;
         state.serialize_field("start_time", &self.start_time())?;
         state.serialize_field("run_time", &self.run_time())?;
         state.serialize_field("cpu_usage", &self.cpu_usage())?;
         state.serialize_field("disk_usage", &self.disk_usage())?;
         if let Some(uid) = self.user_id() {
             state.serialize_field("user_id", &uid.to_string())?;
         }
         if let Some(gid) = self.group_id() {
             let gid = *gid.deref();
             state.serialize_field("group_id", &gid)?;
         }
         if let Some(pid) = self.session_id() {
             state.serialize_field("session_id", &pid.as_u32())?;
         }

         state.end()
     }
 }

 impl Serialize for crate::Cpu {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         let mut state = serializer.serialize_struct("Cpu", 1)?;

         state.serialize_field("cpu_usage", &self.cpu_usage())?;
         state.serialize_field("name", &self.name())?;
         state.serialize_field("vendor_id", &self.vendor_id())?;
         state.serialize_field("brand", &self.brand())?;
         state.serialize_field("frequency", &self.frequency())?;

         state.end()
     }
 }

 impl serde::Serialize for crate::System {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
         let mut state = serializer.serialize_struct("System", 27)?;

         state.serialize_field("IS_SUPPORTED", &<Self as SystemExt>::IS_SUPPORTED)?;
         state.serialize_field("SUPPORTED_SIGNALS", <Self as SystemExt>::SUPPORTED_SIGNALS)?;
         state.serialize_field(
             "MINIMUM_CPU_UPDATE_INTERVAL",
             &<Self as SystemExt>::MINIMUM_CPU_UPDATE_INTERVAL,
         )?;

         state.serialize_field("global_cpu_info", &self.global_cpu_info())?;
         state.serialize_field("cpus", &self.cpus())?;

         state.serialize_field("physical_core_count", &self.physical_core_count())?;
         state.serialize_field("total_memory", &self.total_memory())?;
         state.serialize_field("free_memory", &self.free_memory())?;
         state.serialize_field("available_memory", &self.available_memory())?;
         state.serialize_field("used_memory", &self.used_memory())?;
         state.serialize_field("total_swap", &self.total_swap())?;
         state.serialize_field("free_swap", &self.free_swap())?;
         state.serialize_field("used_swap", &self.used_swap())?;

         state.serialize_field("components", &self.components())?;
         state.serialize_field("users", &self.users())?;
         state.serialize_field("disks", &self.disks())?;
         state.serialize_field("networks", &self.networks())?;

         state.serialize_field("uptime", &self.uptime())?;
         state.serialize_field("boot_time", &self.boot_time())?;
         state.serialize_field("load_average", &self.load_average())?;
         state.serialize_field("name", &self.name())?;
         state.serialize_field("kernel_version", &self.kernel_version())?;
         state.serialize_field("os_version", &self.os_version())?;
         state.serialize_field("long_os_version", &self.long_os_version())?;
         state.serialize_field("distribution_id", &self.distribution_id())?;
         state.serialize_field("host_name", &self.host_name())?;

         state.end()
     }
 }

 impl Serialize for crate::Networks {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         serializer.collect_seq(self.iter())
     }
 }

 impl Serialize for Signal {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         let (index, variant) = match *self {
             Signal::Hangup => (0, "Hangup"),
             Signal::Interrupt => (1, "Interrupt"),
             Signal::Quit => (2, "Quit"),
             Signal::Illegal => (3, "Illegal"),
             Signal::Trap => (4, "Trap"),
             Signal::Abort => (5, "Abort"),
             Signal::IOT => (6, "IOT"),
             Signal::Bus => (7, "Bus"),
             Signal::FloatingPointException => (8, "FloatingPointException"),
             Signal::Kill => (9, "Kill"),
             Signal::User1 => (10, "User1"),
             Signal::Segv => (11, "Segv"),
             Signal::User2 => (12, "User2"),
             Signal::Pipe => (13, "Pipe"),
             Signal::Alarm => (14, "Alarm"),
             Signal::Term => (15, "Term"),
             Signal::Child => (16, "Child"),
             Signal::Continue => (17, "Continue"),
             Signal::Stop => (18, "Stop"),
             Signal::TSTP => (19, "TSTP"),
             Signal::TTIN => (20, "TTIN"),
             Signal::TTOU => (21, "TTOU"),
             Signal::Urgent => (22, "Urgent"),
             Signal::XCPU => (23, "XCPU"),
             Signal::XFSZ => (24, "XFSZ"),
             Signal::VirtualAlarm => (25, "VirtualAlarm"),
             Signal::Profiling => (26, "Profiling"),
             Signal::Winch => (27, "Winch"),
             Signal::IO => (28, "IO"),
             Signal::Poll => (29, "Poll"),
             Signal::Power => (30, "Power"),
             Signal::Sys => (31, "Sys"),
         };

         serializer.serialize_unit_variant("Signal", index, variant)
     }
 }

 impl Serialize for crate::LoadAvg {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         let mut state = serializer.serialize_struct("LoadAvg", 1)?;

         state.serialize_field("one", &self.one)?;
         state.serialize_field("five", &self.five)?;
         state.serialize_field("fifteen", &self.fifteen)?;
         state.end()
     }
 }

 // impl Serialize for crate::NetworkData {
 //     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 //     where
 //         S: Serializer,
 //     {
 //         let mut state = serializer.serialize_struct("NetworkData", 1)?;
 //     }
 // }

 impl Serialize for crate::NetworkData {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         let mut state = serializer.serialize_struct("NetworkData", 1)?;

         state.serialize_field("received", &self.received())?;
         state.serialize_field("total_received", &self.total_received())?;
         state.serialize_field("transmitted", &self.transmitted())?;
         state.serialize_field("total_transmitted", &self.total_transmitted())?;
         state.serialize_field("packets_received", &self.packets_received())?;
         state.serialize_field("total_packets_received", &self.total_packets_received())?;
         state.serialize_field("packets_transmitted", &self.packets_transmitted())?;
         state.serialize_field(
             "total_packets_transmitted",
             &self.total_packets_transmitted(),
         )?;
         state.serialize_field("errors_on_received", &self.errors_on_received())?;
         state.serialize_field("total_errors_on_received", &self.total_errors_on_received())?;
         state.serialize_field("errors_on_transmitted", &self.errors_on_transmitted())?;
         state.serialize_field(
             "total_errors_on_transmitted",
             &self.total_errors_on_transmitted(),
         )?;
         state.serialize_field("mac_address", &self.mac_address())?;

         state.end()
     }
 }

 impl Serialize for crate::Component {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         let mut state = serializer.serialize_struct("Component", 4)?;

         state.serialize_field("temperature", &self.temperature())?;
         state.serialize_field("max", &self.max())?;
         state.serialize_field("critical", &self.critical())?;
         state.serialize_field("label", &self.label())?;

         state.end()
     }
 }

 impl Serialize for crate::User {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         let mut state = serializer.serialize_struct("User", 1)?;

         state.serialize_field("id", &self.id().to_string())?;

         let gid = *self.group_id().deref();
         state.serialize_field("group_id", &gid)?;

         state.serialize_field("name", &self.name())?;
         state.serialize_field("groups", &self.groups())?;

         state.end()
     }
 }

 impl Serialize for DiskKind {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         let (index, variant, maybe_value) = match *self {
             DiskKind::HDD => (0, "HDD", None),
             DiskKind::SSD => (1, "SSD", None),
             DiskKind::Unknown(ref s) => (2, "Unknown", Some(s)),
         };

         if let Some(ref value) = maybe_value {
             serializer.serialize_newtype_variant("DiskKind", index, variant, value)
         } else {
             serializer.serialize_unit_variant("DiskKind", index, variant)
         }
     }
 }

 impl Serialize for ProcessStatus {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         let (index, variant, maybe_value) = match *self {
             ProcessStatus::Idle => (0, "Idle", None),
             ProcessStatus::Run => (1, "Run", None),
             ProcessStatus::Sleep => (2, "Sleep", None),
             ProcessStatus::Stop => (3, "Stop", None),
             ProcessStatus::Zombie => (4, "Zombie", None),
             ProcessStatus::Tracing => (5, "Tracing", None),
             ProcessStatus::Dead => (6, "Dead", None),
             ProcessStatus::Wakekill => (7, "Wakekill", None),
             ProcessStatus::Waking => (8, "Waking", None),
             ProcessStatus::Parked => (9, "Parked", None),
             ProcessStatus::LockBlocked => (10, "LockBlocked", None),
             ProcessStatus::UninterruptibleDiskSleep => (11, "UninterruptibleDiskSleep", None),
             ProcessStatus::Unknown(n) => (12, "Unknown", Some(n)),
         };

         if let Some(ref value) = maybe_value {
             serializer.serialize_newtype_variant("ProcessStatus", index, variant, value)
         } else {
             serializer.serialize_unit_variant("ProcessStatus", index, variant)
         }
     }
 }

 impl Serialize for DiskUsage {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         let mut state = serializer.serialize_struct("DiskUsage", 4)?;

         state.serialize_field("total_written_bytes", &self.total_written_bytes)?;
         state.serialize_field("written_bytes", &self.written_bytes)?;
         state.serialize_field("total_read_bytes", &self.total_read_bytes)?;
         state.serialize_field("read_bytes", &self.read_bytes)?;

         state.end()
     }
 }

 impl Serialize for MacAddr {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         serializer.serialize_newtype_struct("MacAddr", &self.0)
     }
 }
	// Take a look at the license at the top of the repository in the LICENSE file.

	use crate::common::PidExt;
	use crate::{
	ComponentExt, CpuExt, DiskExt, DiskKind, DiskUsage, MacAddr, NetworkExt, NetworksExt,
	ProcessExt, ProcessStatus, Signal, SystemExt, UserExt,
	};
	use serde::{ser::SerializeStruct, Serialize, Serializer};
	use std::ops::Deref;

	impl Serialize for crate::Disk {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: Serializer,
	{
	let mut state = serializer.serialize_struct("Disk", 7)?;

	state.serialize_field("DiskKind", &self.kind())?;
	if let Some(s) = self.name().to_str() {
	state.serialize_field("name", s)?;
	}
	state.serialize_field("file_system", &self.file_system())?;
	state.serialize_field("mount_point", &self.mount_point())?;
	state.serialize_field("total_space", &self.total_space())?;
	state.serialize_field("available_space", &self.available_space())?;
	state.serialize_field("is_removable", &self.is_removable())?;

	state.end()
	}
	}

	impl Serialize for crate::Process {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: Serializer,
	{
	let mut state = serializer.serialize_struct("Process", 18)?;

	state.serialize_field("name", &self.name())?;
	state.serialize_field("cmd", &self.cmd())?;
	state.serialize_field("exe", &self.exe())?;
	state.serialize_field("pid", &self.pid().as_u32())?;
	state.serialize_field("environ", &self.environ())?;
	state.serialize_field("cwd", &self.cwd())?;
	state.serialize_field("root", &self.root())?;
	state.serialize_field("memory", &self.memory())?;
	state.serialize_field("virtual_memory", &self.virtual_memory())?;
	if let Some(pid) = self.parent() {
	state.serialize_field("parent", &pid.as_u32())?;
	}
	state.serialize_field("status", &self.status())?;
	state.serialize_field("start_time", &self.start_time())?;
	state.serialize_field("run_time", &self.run_time())?;
	state.serialize_field("cpu_usage", &self.cpu_usage())?;
	state.serialize_field("disk_usage", &self.disk_usage())?;
	if let Some(uid) = self.user_id() {
	state.serialize_field("user_id", &uid.to_string())?;
	}
	if let Some(gid) = self.group_id() {
	let gid = *gid.deref();
	state.serialize_field("group_id", &gid)?;
	}
	if let Some(pid) = self.session_id() {
	state.serialize_field("session_id", &pid.as_u32())?;
	}

	state.end()
	}
	}

	impl Serialize for crate::Cpu {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: Serializer,
	{
	let mut state = serializer.serialize_struct("Cpu", 1)?;

	state.serialize_field("cpu_usage", &self.cpu_usage())?;
	state.serialize_field("name", &self.name())?;
	state.serialize_field("vendor_id", &self.vendor_id())?;
	state.serialize_field("brand", &self.brand())?;
	state.serialize_field("frequency", &self.frequency())?;

	state.end()
	}
	}

	impl serde::Serialize for crate::System {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: serde::Serializer,
	{
	let mut state = serializer.serialize_struct("System", 27)?;

	state.serialize_field("IS_SUPPORTED", &<Self as SystemExt>::IS_SUPPORTED)?;
	state.serialize_field("SUPPORTED_SIGNALS", <Self as SystemExt>::SUPPORTED_SIGNALS)?;
	state.serialize_field(
	"MINIMUM_CPU_UPDATE_INTERVAL",
	&<Self as SystemExt>::MINIMUM_CPU_UPDATE_INTERVAL,
	)?;

	state.serialize_field("global_cpu_info", &self.global_cpu_info())?;
	state.serialize_field("cpus", &self.cpus())?;

	state.serialize_field("physical_core_count", &self.physical_core_count())?;
	state.serialize_field("total_memory", &self.total_memory())?;
	state.serialize_field("free_memory", &self.free_memory())?;
	state.serialize_field("available_memory", &self.available_memory())?;
	state.serialize_field("used_memory", &self.used_memory())?;
	state.serialize_field("total_swap", &self.total_swap())?;
	state.serialize_field("free_swap", &self.free_swap())?;
	state.serialize_field("used_swap", &self.used_swap())?;

	state.serialize_field("components", &self.components())?;
	state.serialize_field("users", &self.users())?;
	state.serialize_field("disks", &self.disks())?;
	state.serialize_field("networks", &self.networks())?;

	state.serialize_field("uptime", &self.uptime())?;
	state.serialize_field("boot_time", &self.boot_time())?;
	state.serialize_field("load_average", &self.load_average())?;
	state.serialize_field("name", &self.name())?;
	state.serialize_field("kernel_version", &self.kernel_version())?;
	state.serialize_field("os_version", &self.os_version())?;
	state.serialize_field("long_os_version", &self.long_os_version())?;
	state.serialize_field("distribution_id", &self.distribution_id())?;
	state.serialize_field("host_name", &self.host_name())?;

	state.end()
	}
	}

	impl Serialize for crate::Networks {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: Serializer,
	{
	serializer.collect_seq(self.iter())
	}
	}

	impl Serialize for Signal {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: Serializer,
	{
	let (index, variant) = match *self {
	Signal::Hangup => (0, "Hangup"),
	Signal::Interrupt => (1, "Interrupt"),
	Signal::Quit => (2, "Quit"),
	Signal::Illegal => (3, "Illegal"),
	Signal::Trap => (4, "Trap"),
	Signal::Abort => (5, "Abort"),
	Signal::IOT => (6, "IOT"),
	Signal::Bus => (7, "Bus"),
	Signal::FloatingPointException => (8, "FloatingPointException"),
	Signal::Kill => (9, "Kill"),
	Signal::User1 => (10, "User1"),
	Signal::Segv => (11, "Segv"),
	Signal::User2 => (12, "User2"),
	Signal::Pipe => (13, "Pipe"),
	Signal::Alarm => (14, "Alarm"),
	Signal::Term => (15, "Term"),
	Signal::Child => (16, "Child"),
	Signal::Continue => (17, "Continue"),
	Signal::Stop => (18, "Stop"),
	Signal::TSTP => (19, "TSTP"),
	Signal::TTIN => (20, "TTIN"),
	Signal::TTOU => (21, "TTOU"),
	Signal::Urgent => (22, "Urgent"),
	Signal::XCPU => (23, "XCPU"),
	Signal::XFSZ => (24, "XFSZ"),
	Signal::VirtualAlarm => (25, "VirtualAlarm"),
	Signal::Profiling => (26, "Profiling"),
	Signal::Winch => (27, "Winch"),
	Signal::IO => (28, "IO"),
	Signal::Poll => (29, "Poll"),
	Signal::Power => (30, "Power"),
	Signal::Sys => (31, "Sys"),
	};

	serializer.serialize_unit_variant("Signal", index, variant)
	}
	}

	impl Serialize for crate::LoadAvg {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: Serializer,
	{
	let mut state = serializer.serialize_struct("LoadAvg", 1)?;

	state.serialize_field("one", &self.one)?;
	state.serialize_field("five", &self.five)?;
	state.serialize_field("fifteen", &self.fifteen)?;
	state.end()
	}
	}

	// impl Serialize for crate::NetworkData {
	// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	// where
	// S: Serializer,
	// {
	// let mut state = serializer.serialize_struct("NetworkData", 1)?;
	// }
	// }

	impl Serialize for crate::NetworkData {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: Serializer,
	{
	let mut state = serializer.serialize_struct("NetworkData", 1)?;

	state.serialize_field("received", &self.received())?;
	state.serialize_field("total_received", &self.total_received())?;
	state.serialize_field("transmitted", &self.transmitted())?;
	state.serialize_field("total_transmitted", &self.total_transmitted())?;
	state.serialize_field("packets_received", &self.packets_received())?;
	state.serialize_field("total_packets_received", &self.total_packets_received())?;
	state.serialize_field("packets_transmitted", &self.packets_transmitted())?;
	state.serialize_field(
	"total_packets_transmitted",
	&self.total_packets_transmitted(),
	)?;
	state.serialize_field("errors_on_received", &self.errors_on_received())?;
	state.serialize_field("total_errors_on_received", &self.total_errors_on_received())?;
	state.serialize_field("errors_on_transmitted", &self.errors_on_transmitted())?;
	state.serialize_field(
	"total_errors_on_transmitted",
	&self.total_errors_on_transmitted(),
	)?;
	state.serialize_field("mac_address", &self.mac_address())?;

	state.end()
	}
	}

	impl Serialize for crate::Component {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: Serializer,
	{
	let mut state = serializer.serialize_struct("Component", 4)?;

	state.serialize_field("temperature", &self.temperature())?;
	state.serialize_field("max", &self.max())?;
	state.serialize_field("critical", &self.critical())?;
	state.serialize_field("label", &self.label())?;

	state.end()
	}
	}

	impl Serialize for crate::User {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: Serializer,
	{
	let mut state = serializer.serialize_struct("User", 1)?;

	state.serialize_field("id", &self.id().to_string())?;

	let gid = *self.group_id().deref();
	state.serialize_field("group_id", &gid)?;

	state.serialize_field("name", &self.name())?;
	state.serialize_field("groups", &self.groups())?;

	state.end()
	}
	}

	impl Serialize for DiskKind {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: Serializer,
	{
	let (index, variant, maybe_value) = match *self {
	DiskKind::HDD => (0, "HDD", None),
	DiskKind::SSD => (1, "SSD", None),
	DiskKind::Unknown(ref s) => (2, "Unknown", Some(s)),
	};

	if let Some(ref value) = maybe_value {
	serializer.serialize_newtype_variant("DiskKind", index, variant, value)
	} else {
	serializer.serialize_unit_variant("DiskKind", index, variant)
	}
	}
	}

	impl Serialize for ProcessStatus {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: Serializer,
	{
	let (index, variant, maybe_value) = match *self {
	ProcessStatus::Idle => (0, "Idle", None),
	ProcessStatus::Run => (1, "Run", None),
	ProcessStatus::Sleep => (2, "Sleep", None),
	ProcessStatus::Stop => (3, "Stop", None),
	ProcessStatus::Zombie => (4, "Zombie", None),
	ProcessStatus::Tracing => (5, "Tracing", None),
	ProcessStatus::Dead => (6, "Dead", None),
	ProcessStatus::Wakekill => (7, "Wakekill", None),
	ProcessStatus::Waking => (8, "Waking", None),
	ProcessStatus::Parked => (9, "Parked", None),
	ProcessStatus::LockBlocked => (10, "LockBlocked", None),
	ProcessStatus::UninterruptibleDiskSleep => (11, "UninterruptibleDiskSleep", None),
	ProcessStatus::Unknown(n) => (12, "Unknown", Some(n)),
	};

	if let Some(ref value) = maybe_value {
	serializer.serialize_newtype_variant("ProcessStatus", index, variant, value)
	} else {
	serializer.serialize_unit_variant("ProcessStatus", index, variant)
	}
	}
	}

	impl Serialize for DiskUsage {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: Serializer,
	{
	let mut state = serializer.serialize_struct("DiskUsage", 4)?;

	state.serialize_field("total_written_bytes", &self.total_written_bytes)?;
	state.serialize_field("written_bytes", &self.written_bytes)?;
	state.serialize_field("total_read_bytes", &self.total_read_bytes)?;
	state.serialize_field("read_bytes", &self.read_bytes)?;

	state.end()
	}
	}

	impl Serialize for MacAddr {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
	S: Serializer,
	{
	serializer.serialize_newtype_struct("MacAddr", &self.0)
	}
	}