Struct php_codegen::parameter::Parameter

pub struct Parameter {
    pub attributes: Vec<AttributeGroup>,
    pub name: String,
    pub data_type: Option<DataType>,
    pub default: Option<Value>,
    pub modifiers: Vec<Modifier>,
    pub visibility: Option<VisibilityModifier>,
    pub variadic: bool,
}

Fields

attributes: Vec<AttributeGroup>

name: String

data_type: Option<DataType>

default: Option<Value>

modifiers: Vec<Modifier>

visibility: Option<VisibilityModifier>

variadic: bool

Implementations

impl Parameter

pub fn new<T: ToString>(name: T) -> Self

Examples found in repository

examples/simple.rs (line 21)

fn main() {
    let file = File::new()
        .namespaced("App")
        .declare("strict_types", 1)
        .function(
            Function::new("format")
                .document(
                    Document::new()
                        .text("Format a string with the given arguments using sprintf.")
                        .empty_line()
                        .tag("param", "non-empty-string $template")
                        .empty_line()
                        .simple_tag("pure"),
                )
                .parameter(Parameter::new("template").typed(DataType::String))
                .parameter(
                    Parameter::new("args")
                        .variadic()
                        .typed(DataType::Union(vec![
                            DataType::Integer,
                            DataType::Float,
                            DataType::String,
                            DataType::Null,
                        ])),
                )
                .returns(DataType::String)
                .body(vec![
                    "return sprintf($template, ...array_map(",
                    "    static fn ($arg) => is_float($arg) ? number_format($arg, 2) : $arg,",
                    "    array_filter($args, static fn ($arg) => $arg !== null)",
                    "));",
                ]),
        );

    print!("{file}");
}

pub fn attributes(self, attributes: AttributeGroup) -> Self

pub fn typed(self, data_type: DataType) -> Self

Examples found in repository

examples/simple.rs (line 21)

fn main() {
    let file = File::new()
        .namespaced("App")
        .declare("strict_types", 1)
        .function(
            Function::new("format")
                .document(
                    Document::new()
                        .text("Format a string with the given arguments using sprintf.")
                        .empty_line()
                        .tag("param", "non-empty-string $template")
                        .empty_line()
                        .simple_tag("pure"),
                )
                .parameter(Parameter::new("template").typed(DataType::String))
                .parameter(
                    Parameter::new("args")
                        .variadic()
                        .typed(DataType::Union(vec![
                            DataType::Integer,
                            DataType::Float,
                            DataType::String,
                            DataType::Null,
                        ])),
                )
                .returns(DataType::String)
                .body(vec![
                    "return sprintf($template, ...array_map(",
                    "    static fn ($arg) => is_float($arg) ? number_format($arg, 2) : $arg,",
                    "    array_filter($args, static fn ($arg) => $arg !== null)",
                    "));",
                ]),
        );

    print!("{file}");
}

pub fn variadic(self) -> Self

Examples found in repository

examples/simple.rs (line 24)

fn main() {
    let file = File::new()
        .namespaced("App")
        .declare("strict_types", 1)
        .function(
            Function::new("format")
                .document(
                    Document::new()
                        .text("Format a string with the given arguments using sprintf.")
                        .empty_line()
                        .tag("param", "non-empty-string $template")
                        .empty_line()
                        .simple_tag("pure"),
                )
                .parameter(Parameter::new("template").typed(DataType::String))
                .parameter(
                    Parameter::new("args")
                        .variadic()
                        .typed(DataType::Union(vec![
                            DataType::Integer,
                            DataType::Float,
                            DataType::String,
                            DataType::Null,
                        ])),
                )
                .returns(DataType::String)
                .body(vec![
                    "return sprintf($template, ...array_map(",
                    "    static fn ($arg) => is_float($arg) ? number_format($arg, 2) : $arg,",
                    "    array_filter($args, static fn ($arg) => $arg !== null)",
                    "));",
                ]),
        );

    print!("{file}");
}

pub fn default<T: Into<Value>>(self, default: T) -> Self

pub fn modifier(self, modifier: Modifier) -> Self

pub fn public(self) -> Self

pub fn protected(self) -> Self

pub fn private(self) -> Self

pub fn visibility(self, visibility: VisibilityModifier) -> Self

Trait Implementations

impl Debug for Parameter

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

Formats the value using the given formatter.

impl Generator for Parameter

fn generate(&self, indentation: Indentation, level: usize) -> String