Enum ListOutput 

#[non_exhaustive]
pub enum ListOutput {
    SuccessJson(ListJson),
    SuccessUnImplemented {
        stdout: String,
    },
    ErrorUnImplemented {
        stderr: String,
    },
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

SuccessJson(ListJson)

Contains the actual output of the command, parsed

SuccessUnImplemented

This output variant indicates that the command exited with a status code of 0, but its exact output’s parsing code has not yet been implemented yet. PRs welcome!

Fields

stdout: String

ErrorUnImplemented

This output variant indicates that the command did not exit with a status code of 0, but its exact output’s parsing code has not yet been implemented yet. PRs welcome!

Fields

stderr: String

Implementations

impl ListOutput

pub fn success(&self) -> Result<&ListJson>

Returns Error::OutputErrored if it didn’t succeed. Used to make error handling of non-successful commands explicit

Examples found in repository

examples/xcrun-simctl-list.rs (line 10)

fn main() -> Result<(), apple_clis::error::Error> {
	let xcrun_instance = apple_clis::xcrun::XcRunInstance::new()?;
	let simctl_instance = xcrun_instance.simctl();

	let output = simctl_instance.list()?;
	println!("Output: {:#?}", output);

	let devices = output.success()?.devices();
	for device in devices {
		println!("Device: {:#?}", device);
	}

	Ok(())
}

examples/simctl.rs (line 8)

fn main() -> Result<(), apple_clis::error::Error> {
	let xcrun_instance = xcrun::XcRunInstance::new()?;
	let simctl_instance = xcrun_instance.simctl();

	let output = simctl_instance.list()?;
	let devices: Vec<&simctl::list::ListDevice> = output.success()?.devices().collect();
	for device in devices {
		println!(
			"Simulator device {name} is {state:?} and is ready = {ready:?}",
			name = device.name,
			state = device.state,
			ready = device.ready()
		);
	}

	// the .names() and .ipads() are implemented on extension traits imported with
	// use apple_clis::prelude::*;
	// to make finding devices easier and more ergonomic
	let ipad_simulator: &IPadVariant = output
		.get_success()
		.expect("to succeed")
		.devices()
		.names()
		.ipads()
		.max()
		.expect("an iPad simulator to be available");
	println!("Found an {} simulator", ipad_simulator);

	if let IPadVariant::Pro {
		size, generation, ..
	} = ipad_simulator
	{
		let inches: f32 = size.inches();
		let gen: u8 = match generation {
			// generations can be M1 or gen 6
			Generation::Num(num) => num.get(),	
			Generation::M(m_gen) => m_gen.get_u8(),
		};
		println!(
			"Ooh, its a pro size {} {:?} generation {} {:?}",
			size, inches, generation, gen,
		);
	}

	// boot the simulator
	let boot_result = simctl_instance.boot(DeviceName::from(*ipad_simulator))?;
	match boot_result {
		simctl::boot::BootOutput::SuccessUnImplemented { .. } => println!("Booted the simulator"),
		simctl::boot::BootOutput::AlreadyBooted => println!("Simulator was already booted"),
		_ => println!("PRs welcome to cover more cases"),
	}

	// open the simulator
	let open_instance = open::OpenCLIInstance::new()?;
	open_instance.open_well_known(&open::well_known::WellKnown::Simulator)?;

	Ok(())
}

pub fn unwrap_success(&self) -> &ListJson

pub fn get_success(&self) -> Option<&ListJson>

Examples found in repository

examples/simctl.rs (line 22)

fn main() -> Result<(), apple_clis::error::Error> {
	let xcrun_instance = xcrun::XcRunInstance::new()?;
	let simctl_instance = xcrun_instance.simctl();

	let output = simctl_instance.list()?;
	let devices: Vec<&simctl::list::ListDevice> = output.success()?.devices().collect();
	for device in devices {
		println!(
			"Simulator device {name} is {state:?} and is ready = {ready:?}",
			name = device.name,
			state = device.state,
			ready = device.ready()
		);
	}

	// the .names() and .ipads() are implemented on extension traits imported with
	// use apple_clis::prelude::*;
	// to make finding devices easier and more ergonomic
	let ipad_simulator: &IPadVariant = output
		.get_success()
		.expect("to succeed")
		.devices()
		.names()
		.ipads()
		.max()
		.expect("an iPad simulator to be available");
	println!("Found an {} simulator", ipad_simulator);

	if let IPadVariant::Pro {
		size, generation, ..
	} = ipad_simulator
	{
		let inches: f32 = size.inches();
		let gen: u8 = match generation {
			// generations can be M1 or gen 6
			Generation::Num(num) => num.get(),	
			Generation::M(m_gen) => m_gen.get_u8(),
		};
		println!(
			"Ooh, its a pro size {} {:?} generation {} {:?}",
			size, inches, generation, gen,
		);
	}

	// boot the simulator
	let boot_result = simctl_instance.boot(DeviceName::from(*ipad_simulator))?;
	match boot_result {
		simctl::boot::BootOutput::SuccessUnImplemented { .. } => println!("Booted the simulator"),
		simctl::boot::BootOutput::AlreadyBooted => println!("Simulator was already booted"),
		_ => println!("PRs welcome to cover more cases"),
	}

	// open the simulator
	let open_instance = open::OpenCLIInstance::new()?;
	open_instance.open_well_known(&open::well_known::WellKnown::Simulator)?;

	Ok(())
}

pub fn get_success_reported(&self) -> Result<&ListJson, Report>

Only used in CLI prefer Self::get_success

Trait Implementations

impl Debug for ListOutput

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PublicCommandOutput for ListOutput

type PrimarySuccess = ListJson

If applicable, what the commands successful output should be. If no output is application, often a bool as returned in PublicCommandOutput::successful

fn success(&self) -> Result<&Self::PrimarySuccess>

Will return Error::OutputErrored if the command was not successful.

fn successful(&self) -> bool

Did command exit with an ‘expected’ success case?

fn failed(&self) -> bool

impl Serialize for ListOutput

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.