Struct ArgumentList 

pub struct ArgumentList {
    pub arguments: Vec<Argument>,
}

List of arguments for a component

Fields

arguments: Vec<Argument>

Implementations

impl ArgumentList

pub fn new(arguments: Vec<Argument>) -> Self

pub fn empty() -> Self

pub fn as_map(&self) -> HashMap<String, Value>

pub fn get_named(&self, key: &str) -> Option<&Value>

Examples found in repository

examples/usage.rs (line 63)

fn example_2() {
    println!("Example 2: Extracting named and positional arguments\n");

    let input = r#"Button(text: "Click Me", enabled: true, color: blue)"#;
    println!("Input: {}\n", input);

    match parse_component(input) {
        Ok(component) => {
            println!("✓ Component: {}", component.name);

            // Get named argument
            if let Some(text) = component.arguments.get_named("text") {
                println!("✓ Text argument: {:?}", text);
            }

            // Get boolean argument
            if let Some(Value::Boolean(enabled)) = component.arguments.get_named("enabled") {
                println!("✓ Enabled: {}", enabled);
            }

            // Iterate all arguments
            println!("\nAll arguments:");
            for (i, arg) in component.arguments.arguments.iter().enumerate() {
                match arg {
                    Argument::Named { key, value } => {
                        println!("  [{}] {} = {:?}", i, key, value);
                    }
                    Argument::Positioned { position, value } => {
                        println!("  [{}] pos {} = {:?}", i, position, value);
                    }
                }
            }
        }
        Err(errors) => {
            print_parse_errors("input.hypen", input, &errors);
        }
    }
}

pub fn get_positioned(&self, position: usize) -> Option<&Value>

Trait Implementations

impl Clone for ArgumentList

fn clone(&self) -> ArgumentList

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ArgumentList

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ArgumentList

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ArgumentList

fn eq(&self, other: &ArgumentList) -> 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 ArgumentList

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 ArgumentList