Enum Arg 

pub enum Arg {
    Flag(String),
    Option(String, String),
    Array(String, Vec<String>),
    Positional(String),
}

A CLI argument passed to an executed command.

Variants

• Flag(String): A command-line flag (e.g., --verbose, -v)
• Option(String, String): A key-value pair (e.g., --port 8080, --name=alice)
• Array(String, Vec<String>): A key with multiple values (e.g., --items [a,b,c])
• Positional(String): A positional argument without prefix (e.g., script.sh, ws://127.0.0.1:10000)

Examples:

use zombienet_configuration::shared::types::Arg;

let flag_arg: Arg = "myflag".into();
let option_arg: Arg = ("name", "value").into();

assert!(matches!(flag_arg, Arg::Flag(value) if value == "myflag"));
assert!(matches!(option_arg, Arg::Option(name, value) if name == "name" && value == "value"));

Variants

Flag(String)

Option(String, String)

Array(String, Vec<String>)

Positional(String)

Implementations

impl Arg

pub fn to_vec(&self) -> Vec<String>

Convert Arg to a vec of String

Trait Implementations

impl Clone for Arg

fn clone(&self) -> Arg

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Arg

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Arg

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&str> for Arg

fn from(flag: &str) -> Self

Converts to this type from the input type.

impl<T> From<(&str, &[T])> for Arg

where T: AsRef<str> + Clone,

fn from((option, values): (&str, &[T])) -> Self

Converts to this type from the input type.

impl From<(&str, &str)> for Arg

fn from((option, value): (&str, &str)) -> Self

Converts to this type from the input type.

impl<T> From<(&str, Vec<T>)> for Arg

where T: AsRef<str>,

fn from((option, values): (&str, Vec<T>)) -> Self

Converts to this type from the input type.

impl PartialEq for Arg

fn eq(&self, other: &Arg) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Arg

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Arg