Struct CurrencyOptions 

pub struct CurrencyOptions {

    pub symbol: String,
    pub require_symbol: bool,
    pub allow_space_after_symbol: bool,
    pub symbol_after_digits: bool,
    pub allow_negatives: bool,
    pub parens_for_negatives: bool,
    pub negative_sign_before_digits: bool,
    pub negative_sign_after_digits: bool,
    pub allow_negative_sign_placeholder: bool,
    pub thousands_separator: char,
    pub decimal_separator: char,
    pub allow_decimal: bool,
    pub require_decimal: bool,
    pub digits_after_decimal: Vec<usize>,
    pub allow_space_after_digits: bool,
}

Options for currency validation

This struct provides configuration for validating currency strings with support for various formats, symbols, and regional conventions.

Fields

symbol: String

Currency symbol (e.g., “$”, “€”, “¥”)

require_symbol: bool

Require the currency symbol to be present

allow_space_after_symbol: bool

Allow space after the symbol

symbol_after_digits: bool

Symbol appears after the digits instead of before

allow_negatives: bool

Allow negative values

parens_for_negatives: bool

Use parentheses for negative values instead of minus sign

negative_sign_before_digits: bool

Negative sign appears before the digits

negative_sign_after_digits: bool

Negative sign appears after the digits

allow_negative_sign_placeholder: bool

Allow space placeholder for negative sign (e.g., “R 123” and “R-123”)

thousands_separator: char

Thousands separator character

decimal_separator: char

Decimal separator character

allow_decimal: bool

Allow decimal portion

require_decimal: bool

Require decimal portion

digits_after_decimal: Vec<usize>

Allowed number of digits after decimal (e.g., vec![2] for exactly 2 digits)

allow_space_after_digits: bool

Allow space after digits

Implementations

impl CurrencyOptions

pub fn new() -> Self

Create a new CurrencyOptions with default values

Examples found in repository

examples/currency_usage.rs (line 15)

fn main() {
    println!("=== Currency Validator Examples ===\n");

    // Example 1: Default USD format
    println!("1. Default USD format:");
    let usd_values = vec!["$10,123.45", "10,123.45", "-$99.99", "$.99"];
    for val in usd_values {
        println!("   '{}' -> {}", val, is_currency(val, None));
    }

    // Example 2: Euro (Italian format)
    println!("\n2. Euro (Italian format - €1.234,56):");
    let euro_options = CurrencyOptions::new()
        .symbol("€")
        .thousands_separator('.')
        .decimal_separator(',')
        .allow_space_after_symbol(true);
    
    let euro_values = vec!["€1.234,56", "€ 1.234,56", "-€10,50"];
    for val in euro_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(euro_options.clone())));
    }

    // Example 3: Chinese Yuan
    println!("\n3. Chinese Yuan (¥):");
    let yuan_options = CurrencyOptions::new()
        .symbol("¥")
        .negative_sign_before_digits(true);
    
    let yuan_values = vec!["¥1,234.56", "¥-999.99", "123,456.78"];
    for val in yuan_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(yuan_options.clone())));
    }

    // Example 4: South African Rand
    println!("\n4. South African Rand (R 123 or R-123):");
    let rand_options = CurrencyOptions::new()
        .symbol("R")
        .thousands_separator(' ')
        .decimal_separator(',')
        .negative_sign_before_digits(true)
        .allow_negative_sign_placeholder(true);
    
    let rand_values = vec!["R 10 123,45", "R-10 123,45", "R 123,45"];
    for val in rand_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(rand_options.clone())));
    }

    // Example 5: Brazilian Real
    println!("\n5. Brazilian Real (R$ 1.234,56):");
    let real_options = CurrencyOptions::new()
        .symbol("R$")
        .require_symbol(true)
        .allow_space_after_symbol(true)
        .thousands_separator('.')
        .decimal_separator(',');
    
    let real_values = vec!["R$ 1.400,00", "R$ 400,00", "$ 1.400,00"];
    for val in real_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(real_options.clone())));
    }

    // Example 6: Parentheses for negatives
    println!("\n6. Parentheses for negatives:");
    let parens_options = CurrencyOptions::new()
        .parens_for_negatives(true);
    
    let parens_values = vec!["($1,234.56)", "$1,234.56", "(1,234.56)", "-$1,234.56"];
    for val in parens_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(parens_options.clone())));
    }

    // Example 7: Custom decimal digits
    println!("\n7. Custom decimal digits (1 or 3 digits):");
    let custom_decimal_options = CurrencyOptions::new()
        .digits_after_decimal(vec![1, 3]);
    
    let custom_values = vec!["$10.5", "$10.123", "$10.12", "$10.1234"];
    for val in custom_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(custom_decimal_options.clone())));
    }

    println!("\n=== All examples completed ===");
}

pub fn symbol(self, symbol: impl Into<String>) -> Self

Set the currency symbol

Examples found in repository

examples/currency_usage.rs (line 16)

fn main() {
    println!("=== Currency Validator Examples ===\n");

    // Example 1: Default USD format
    println!("1. Default USD format:");
    let usd_values = vec!["$10,123.45", "10,123.45", "-$99.99", "$.99"];
    for val in usd_values {
        println!("   '{}' -> {}", val, is_currency(val, None));
    }

    // Example 2: Euro (Italian format)
    println!("\n2. Euro (Italian format - €1.234,56):");
    let euro_options = CurrencyOptions::new()
        .symbol("€")
        .thousands_separator('.')
        .decimal_separator(',')
        .allow_space_after_symbol(true);
    
    let euro_values = vec!["€1.234,56", "€ 1.234,56", "-€10,50"];
    for val in euro_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(euro_options.clone())));
    }

    // Example 3: Chinese Yuan
    println!("\n3. Chinese Yuan (¥):");
    let yuan_options = CurrencyOptions::new()
        .symbol("¥")
        .negative_sign_before_digits(true);
    
    let yuan_values = vec!["¥1,234.56", "¥-999.99", "123,456.78"];
    for val in yuan_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(yuan_options.clone())));
    }

    // Example 4: South African Rand
    println!("\n4. South African Rand (R 123 or R-123):");
    let rand_options = CurrencyOptions::new()
        .symbol("R")
        .thousands_separator(' ')
        .decimal_separator(',')
        .negative_sign_before_digits(true)
        .allow_negative_sign_placeholder(true);
    
    let rand_values = vec!["R 10 123,45", "R-10 123,45", "R 123,45"];
    for val in rand_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(rand_options.clone())));
    }

    // Example 5: Brazilian Real
    println!("\n5. Brazilian Real (R$ 1.234,56):");
    let real_options = CurrencyOptions::new()
        .symbol("R$")
        .require_symbol(true)
        .allow_space_after_symbol(true)
        .thousands_separator('.')
        .decimal_separator(',');
    
    let real_values = vec!["R$ 1.400,00", "R$ 400,00", "$ 1.400,00"];
    for val in real_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(real_options.clone())));
    }

    // Example 6: Parentheses for negatives
    println!("\n6. Parentheses for negatives:");
    let parens_options = CurrencyOptions::new()
        .parens_for_negatives(true);
    
    let parens_values = vec!["($1,234.56)", "$1,234.56", "(1,234.56)", "-$1,234.56"];
    for val in parens_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(parens_options.clone())));
    }

    // Example 7: Custom decimal digits
    println!("\n7. Custom decimal digits (1 or 3 digits):");
    let custom_decimal_options = CurrencyOptions::new()
        .digits_after_decimal(vec![1, 3]);
    
    let custom_values = vec!["$10.5", "$10.123", "$10.12", "$10.1234"];
    for val in custom_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(custom_decimal_options.clone())));
    }

    println!("\n=== All examples completed ===");
}

pub fn require_symbol(self, require: bool) -> Self

Set whether symbol is required

Examples found in repository

examples/currency_usage.rs (line 55)

fn main() {
    println!("=== Currency Validator Examples ===\n");

    // Example 1: Default USD format
    println!("1. Default USD format:");
    let usd_values = vec!["$10,123.45", "10,123.45", "-$99.99", "$.99"];
    for val in usd_values {
        println!("   '{}' -> {}", val, is_currency(val, None));
    }

    // Example 2: Euro (Italian format)
    println!("\n2. Euro (Italian format - €1.234,56):");
    let euro_options = CurrencyOptions::new()
        .symbol("€")
        .thousands_separator('.')
        .decimal_separator(',')
        .allow_space_after_symbol(true);
    
    let euro_values = vec!["€1.234,56", "€ 1.234,56", "-€10,50"];
    for val in euro_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(euro_options.clone())));
    }

    // Example 3: Chinese Yuan
    println!("\n3. Chinese Yuan (¥):");
    let yuan_options = CurrencyOptions::new()
        .symbol("¥")
        .negative_sign_before_digits(true);
    
    let yuan_values = vec!["¥1,234.56", "¥-999.99", "123,456.78"];
    for val in yuan_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(yuan_options.clone())));
    }

    // Example 4: South African Rand
    println!("\n4. South African Rand (R 123 or R-123):");
    let rand_options = CurrencyOptions::new()
        .symbol("R")
        .thousands_separator(' ')
        .decimal_separator(',')
        .negative_sign_before_digits(true)
        .allow_negative_sign_placeholder(true);
    
    let rand_values = vec!["R 10 123,45", "R-10 123,45", "R 123,45"];
    for val in rand_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(rand_options.clone())));
    }

    // Example 5: Brazilian Real
    println!("\n5. Brazilian Real (R$ 1.234,56):");
    let real_options = CurrencyOptions::new()
        .symbol("R$")
        .require_symbol(true)
        .allow_space_after_symbol(true)
        .thousands_separator('.')
        .decimal_separator(',');
    
    let real_values = vec!["R$ 1.400,00", "R$ 400,00", "$ 1.400,00"];
    for val in real_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(real_options.clone())));
    }

    // Example 6: Parentheses for negatives
    println!("\n6. Parentheses for negatives:");
    let parens_options = CurrencyOptions::new()
        .parens_for_negatives(true);
    
    let parens_values = vec!["($1,234.56)", "$1,234.56", "(1,234.56)", "-$1,234.56"];
    for val in parens_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(parens_options.clone())));
    }

    // Example 7: Custom decimal digits
    println!("\n7. Custom decimal digits (1 or 3 digits):");
    let custom_decimal_options = CurrencyOptions::new()
        .digits_after_decimal(vec![1, 3]);
    
    let custom_values = vec!["$10.5", "$10.123", "$10.12", "$10.1234"];
    for val in custom_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(custom_decimal_options.clone())));
    }

    println!("\n=== All examples completed ===");
}

pub fn allow_space_after_symbol(self, allow: bool) -> Self

Set whether to allow space after symbol

Examples found in repository

examples/currency_usage.rs (line 19)

fn main() {
    println!("=== Currency Validator Examples ===\n");

    // Example 1: Default USD format
    println!("1. Default USD format:");
    let usd_values = vec!["$10,123.45", "10,123.45", "-$99.99", "$.99"];
    for val in usd_values {
        println!("   '{}' -> {}", val, is_currency(val, None));
    }

    // Example 2: Euro (Italian format)
    println!("\n2. Euro (Italian format - €1.234,56):");
    let euro_options = CurrencyOptions::new()
        .symbol("€")
        .thousands_separator('.')
        .decimal_separator(',')
        .allow_space_after_symbol(true);
    
    let euro_values = vec!["€1.234,56", "€ 1.234,56", "-€10,50"];
    for val in euro_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(euro_options.clone())));
    }

    // Example 3: Chinese Yuan
    println!("\n3. Chinese Yuan (¥):");
    let yuan_options = CurrencyOptions::new()
        .symbol("¥")
        .negative_sign_before_digits(true);
    
    let yuan_values = vec!["¥1,234.56", "¥-999.99", "123,456.78"];
    for val in yuan_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(yuan_options.clone())));
    }

    // Example 4: South African Rand
    println!("\n4. South African Rand (R 123 or R-123):");
    let rand_options = CurrencyOptions::new()
        .symbol("R")
        .thousands_separator(' ')
        .decimal_separator(',')
        .negative_sign_before_digits(true)
        .allow_negative_sign_placeholder(true);
    
    let rand_values = vec!["R 10 123,45", "R-10 123,45", "R 123,45"];
    for val in rand_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(rand_options.clone())));
    }

    // Example 5: Brazilian Real
    println!("\n5. Brazilian Real (R$ 1.234,56):");
    let real_options = CurrencyOptions::new()
        .symbol("R$")
        .require_symbol(true)
        .allow_space_after_symbol(true)
        .thousands_separator('.')
        .decimal_separator(',');
    
    let real_values = vec!["R$ 1.400,00", "R$ 400,00", "$ 1.400,00"];
    for val in real_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(real_options.clone())));
    }

    // Example 6: Parentheses for negatives
    println!("\n6. Parentheses for negatives:");
    let parens_options = CurrencyOptions::new()
        .parens_for_negatives(true);
    
    let parens_values = vec!["($1,234.56)", "$1,234.56", "(1,234.56)", "-$1,234.56"];
    for val in parens_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(parens_options.clone())));
    }

    // Example 7: Custom decimal digits
    println!("\n7. Custom decimal digits (1 or 3 digits):");
    let custom_decimal_options = CurrencyOptions::new()
        .digits_after_decimal(vec![1, 3]);
    
    let custom_values = vec!["$10.5", "$10.123", "$10.12", "$10.1234"];
    for val in custom_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(custom_decimal_options.clone())));
    }

    println!("\n=== All examples completed ===");
}

pub fn symbol_after_digits(self, after: bool) -> Self

Set whether symbol appears after digits

pub fn allow_negatives(self, allow: bool) -> Self

Set whether negatives are allowed

pub fn parens_for_negatives(self, use_parens: bool) -> Self

Set whether to use parentheses for negatives

Examples found in repository

examples/currency_usage.rs (line 68)

fn main() {
    println!("=== Currency Validator Examples ===\n");

    // Example 1: Default USD format
    println!("1. Default USD format:");
    let usd_values = vec!["$10,123.45", "10,123.45", "-$99.99", "$.99"];
    for val in usd_values {
        println!("   '{}' -> {}", val, is_currency(val, None));
    }

    // Example 2: Euro (Italian format)
    println!("\n2. Euro (Italian format - €1.234,56):");
    let euro_options = CurrencyOptions::new()
        .symbol("€")
        .thousands_separator('.')
        .decimal_separator(',')
        .allow_space_after_symbol(true);
    
    let euro_values = vec!["€1.234,56", "€ 1.234,56", "-€10,50"];
    for val in euro_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(euro_options.clone())));
    }

    // Example 3: Chinese Yuan
    println!("\n3. Chinese Yuan (¥):");
    let yuan_options = CurrencyOptions::new()
        .symbol("¥")
        .negative_sign_before_digits(true);
    
    let yuan_values = vec!["¥1,234.56", "¥-999.99", "123,456.78"];
    for val in yuan_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(yuan_options.clone())));
    }

    // Example 4: South African Rand
    println!("\n4. South African Rand (R 123 or R-123):");
    let rand_options = CurrencyOptions::new()
        .symbol("R")
        .thousands_separator(' ')
        .decimal_separator(',')
        .negative_sign_before_digits(true)
        .allow_negative_sign_placeholder(true);
    
    let rand_values = vec!["R 10 123,45", "R-10 123,45", "R 123,45"];
    for val in rand_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(rand_options.clone())));
    }

    // Example 5: Brazilian Real
    println!("\n5. Brazilian Real (R$ 1.234,56):");
    let real_options = CurrencyOptions::new()
        .symbol("R$")
        .require_symbol(true)
        .allow_space_after_symbol(true)
        .thousands_separator('.')
        .decimal_separator(',');
    
    let real_values = vec!["R$ 1.400,00", "R$ 400,00", "$ 1.400,00"];
    for val in real_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(real_options.clone())));
    }

    // Example 6: Parentheses for negatives
    println!("\n6. Parentheses for negatives:");
    let parens_options = CurrencyOptions::new()
        .parens_for_negatives(true);
    
    let parens_values = vec!["($1,234.56)", "$1,234.56", "(1,234.56)", "-$1,234.56"];
    for val in parens_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(parens_options.clone())));
    }

    // Example 7: Custom decimal digits
    println!("\n7. Custom decimal digits (1 or 3 digits):");
    let custom_decimal_options = CurrencyOptions::new()
        .digits_after_decimal(vec![1, 3]);
    
    let custom_values = vec!["$10.5", "$10.123", "$10.12", "$10.1234"];
    for val in custom_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(custom_decimal_options.clone())));
    }

    println!("\n=== All examples completed ===");
}

pub fn thousands_separator(self, sep: char) -> Self

Set thousands separator character

Examples found in repository

examples/currency_usage.rs (line 17)

fn main() {
    println!("=== Currency Validator Examples ===\n");

    // Example 1: Default USD format
    println!("1. Default USD format:");
    let usd_values = vec!["$10,123.45", "10,123.45", "-$99.99", "$.99"];
    for val in usd_values {
        println!("   '{}' -> {}", val, is_currency(val, None));
    }

    // Example 2: Euro (Italian format)
    println!("\n2. Euro (Italian format - €1.234,56):");
    let euro_options = CurrencyOptions::new()
        .symbol("€")
        .thousands_separator('.')
        .decimal_separator(',')
        .allow_space_after_symbol(true);
    
    let euro_values = vec!["€1.234,56", "€ 1.234,56", "-€10,50"];
    for val in euro_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(euro_options.clone())));
    }

    // Example 3: Chinese Yuan
    println!("\n3. Chinese Yuan (¥):");
    let yuan_options = CurrencyOptions::new()
        .symbol("¥")
        .negative_sign_before_digits(true);
    
    let yuan_values = vec!["¥1,234.56", "¥-999.99", "123,456.78"];
    for val in yuan_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(yuan_options.clone())));
    }

    // Example 4: South African Rand
    println!("\n4. South African Rand (R 123 or R-123):");
    let rand_options = CurrencyOptions::new()
        .symbol("R")
        .thousands_separator(' ')
        .decimal_separator(',')
        .negative_sign_before_digits(true)
        .allow_negative_sign_placeholder(true);
    
    let rand_values = vec!["R 10 123,45", "R-10 123,45", "R 123,45"];
    for val in rand_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(rand_options.clone())));
    }

    // Example 5: Brazilian Real
    println!("\n5. Brazilian Real (R$ 1.234,56):");
    let real_options = CurrencyOptions::new()
        .symbol("R$")
        .require_symbol(true)
        .allow_space_after_symbol(true)
        .thousands_separator('.')
        .decimal_separator(',');
    
    let real_values = vec!["R$ 1.400,00", "R$ 400,00", "$ 1.400,00"];
    for val in real_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(real_options.clone())));
    }

    // Example 6: Parentheses for negatives
    println!("\n6. Parentheses for negatives:");
    let parens_options = CurrencyOptions::new()
        .parens_for_negatives(true);
    
    let parens_values = vec!["($1,234.56)", "$1,234.56", "(1,234.56)", "-$1,234.56"];
    for val in parens_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(parens_options.clone())));
    }

    // Example 7: Custom decimal digits
    println!("\n7. Custom decimal digits (1 or 3 digits):");
    let custom_decimal_options = CurrencyOptions::new()
        .digits_after_decimal(vec![1, 3]);
    
    let custom_values = vec!["$10.5", "$10.123", "$10.12", "$10.1234"];
    for val in custom_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(custom_decimal_options.clone())));
    }

    println!("\n=== All examples completed ===");
}

pub fn decimal_separator(self, sep: char) -> Self

Set decimal separator character

Examples found in repository

examples/currency_usage.rs (line 18)

fn main() {
    println!("=== Currency Validator Examples ===\n");

    // Example 1: Default USD format
    println!("1. Default USD format:");
    let usd_values = vec!["$10,123.45", "10,123.45", "-$99.99", "$.99"];
    for val in usd_values {
        println!("   '{}' -> {}", val, is_currency(val, None));
    }

    // Example 2: Euro (Italian format)
    println!("\n2. Euro (Italian format - €1.234,56):");
    let euro_options = CurrencyOptions::new()
        .symbol("€")
        .thousands_separator('.')
        .decimal_separator(',')
        .allow_space_after_symbol(true);
    
    let euro_values = vec!["€1.234,56", "€ 1.234,56", "-€10,50"];
    for val in euro_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(euro_options.clone())));
    }

    // Example 3: Chinese Yuan
    println!("\n3. Chinese Yuan (¥):");
    let yuan_options = CurrencyOptions::new()
        .symbol("¥")
        .negative_sign_before_digits(true);
    
    let yuan_values = vec!["¥1,234.56", "¥-999.99", "123,456.78"];
    for val in yuan_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(yuan_options.clone())));
    }

    // Example 4: South African Rand
    println!("\n4. South African Rand (R 123 or R-123):");
    let rand_options = CurrencyOptions::new()
        .symbol("R")
        .thousands_separator(' ')
        .decimal_separator(',')
        .negative_sign_before_digits(true)
        .allow_negative_sign_placeholder(true);
    
    let rand_values = vec!["R 10 123,45", "R-10 123,45", "R 123,45"];
    for val in rand_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(rand_options.clone())));
    }

    // Example 5: Brazilian Real
    println!("\n5. Brazilian Real (R$ 1.234,56):");
    let real_options = CurrencyOptions::new()
        .symbol("R$")
        .require_symbol(true)
        .allow_space_after_symbol(true)
        .thousands_separator('.')
        .decimal_separator(',');
    
    let real_values = vec!["R$ 1.400,00", "R$ 400,00", "$ 1.400,00"];
    for val in real_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(real_options.clone())));
    }

    // Example 6: Parentheses for negatives
    println!("\n6. Parentheses for negatives:");
    let parens_options = CurrencyOptions::new()
        .parens_for_negatives(true);
    
    let parens_values = vec!["($1,234.56)", "$1,234.56", "(1,234.56)", "-$1,234.56"];
    for val in parens_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(parens_options.clone())));
    }

    // Example 7: Custom decimal digits
    println!("\n7. Custom decimal digits (1 or 3 digits):");
    let custom_decimal_options = CurrencyOptions::new()
        .digits_after_decimal(vec![1, 3]);
    
    let custom_values = vec!["$10.5", "$10.123", "$10.12", "$10.1234"];
    for val in custom_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(custom_decimal_options.clone())));
    }

    println!("\n=== All examples completed ===");
}

pub fn allow_decimal(self, allow: bool) -> Self

Set whether decimals are allowed

pub fn require_decimal(self, require: bool) -> Self

Set whether decimal is required

pub fn digits_after_decimal(self, digits: Vec<usize>) -> Self

Set allowed digits after decimal

Examples found in repository

examples/currency_usage.rs (line 78)

fn main() {
    println!("=== Currency Validator Examples ===\n");

    // Example 1: Default USD format
    println!("1. Default USD format:");
    let usd_values = vec!["$10,123.45", "10,123.45", "-$99.99", "$.99"];
    for val in usd_values {
        println!("   '{}' -> {}", val, is_currency(val, None));
    }

    // Example 2: Euro (Italian format)
    println!("\n2. Euro (Italian format - €1.234,56):");
    let euro_options = CurrencyOptions::new()
        .symbol("€")
        .thousands_separator('.')
        .decimal_separator(',')
        .allow_space_after_symbol(true);
    
    let euro_values = vec!["€1.234,56", "€ 1.234,56", "-€10,50"];
    for val in euro_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(euro_options.clone())));
    }

    // Example 3: Chinese Yuan
    println!("\n3. Chinese Yuan (¥):");
    let yuan_options = CurrencyOptions::new()
        .symbol("¥")
        .negative_sign_before_digits(true);
    
    let yuan_values = vec!["¥1,234.56", "¥-999.99", "123,456.78"];
    for val in yuan_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(yuan_options.clone())));
    }

    // Example 4: South African Rand
    println!("\n4. South African Rand (R 123 or R-123):");
    let rand_options = CurrencyOptions::new()
        .symbol("R")
        .thousands_separator(' ')
        .decimal_separator(',')
        .negative_sign_before_digits(true)
        .allow_negative_sign_placeholder(true);
    
    let rand_values = vec!["R 10 123,45", "R-10 123,45", "R 123,45"];
    for val in rand_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(rand_options.clone())));
    }

    // Example 5: Brazilian Real
    println!("\n5. Brazilian Real (R$ 1.234,56):");
    let real_options = CurrencyOptions::new()
        .symbol("R$")
        .require_symbol(true)
        .allow_space_after_symbol(true)
        .thousands_separator('.')
        .decimal_separator(',');
    
    let real_values = vec!["R$ 1.400,00", "R$ 400,00", "$ 1.400,00"];
    for val in real_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(real_options.clone())));
    }

    // Example 6: Parentheses for negatives
    println!("\n6. Parentheses for negatives:");
    let parens_options = CurrencyOptions::new()
        .parens_for_negatives(true);
    
    let parens_values = vec!["($1,234.56)", "$1,234.56", "(1,234.56)", "-$1,234.56"];
    for val in parens_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(parens_options.clone())));
    }

    // Example 7: Custom decimal digits
    println!("\n7. Custom decimal digits (1 or 3 digits):");
    let custom_decimal_options = CurrencyOptions::new()
        .digits_after_decimal(vec![1, 3]);
    
    let custom_values = vec!["$10.5", "$10.123", "$10.12", "$10.1234"];
    for val in custom_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(custom_decimal_options.clone())));
    }

    println!("\n=== All examples completed ===");
}

pub fn negative_sign_before_digits(self, before: bool) -> Self

Set whether negative sign appears before digits

Examples found in repository

examples/currency_usage.rs (line 30)

fn main() {
    println!("=== Currency Validator Examples ===\n");

    // Example 1: Default USD format
    println!("1. Default USD format:");
    let usd_values = vec!["$10,123.45", "10,123.45", "-$99.99", "$.99"];
    for val in usd_values {
        println!("   '{}' -> {}", val, is_currency(val, None));
    }

    // Example 2: Euro (Italian format)
    println!("\n2. Euro (Italian format - €1.234,56):");
    let euro_options = CurrencyOptions::new()
        .symbol("€")
        .thousands_separator('.')
        .decimal_separator(',')
        .allow_space_after_symbol(true);
    
    let euro_values = vec!["€1.234,56", "€ 1.234,56", "-€10,50"];
    for val in euro_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(euro_options.clone())));
    }

    // Example 3: Chinese Yuan
    println!("\n3. Chinese Yuan (¥):");
    let yuan_options = CurrencyOptions::new()
        .symbol("¥")
        .negative_sign_before_digits(true);
    
    let yuan_values = vec!["¥1,234.56", "¥-999.99", "123,456.78"];
    for val in yuan_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(yuan_options.clone())));
    }

    // Example 4: South African Rand
    println!("\n4. South African Rand (R 123 or R-123):");
    let rand_options = CurrencyOptions::new()
        .symbol("R")
        .thousands_separator(' ')
        .decimal_separator(',')
        .negative_sign_before_digits(true)
        .allow_negative_sign_placeholder(true);
    
    let rand_values = vec!["R 10 123,45", "R-10 123,45", "R 123,45"];
    for val in rand_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(rand_options.clone())));
    }

    // Example 5: Brazilian Real
    println!("\n5. Brazilian Real (R$ 1.234,56):");
    let real_options = CurrencyOptions::new()
        .symbol("R$")
        .require_symbol(true)
        .allow_space_after_symbol(true)
        .thousands_separator('.')
        .decimal_separator(',');
    
    let real_values = vec!["R$ 1.400,00", "R$ 400,00", "$ 1.400,00"];
    for val in real_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(real_options.clone())));
    }

    // Example 6: Parentheses for negatives
    println!("\n6. Parentheses for negatives:");
    let parens_options = CurrencyOptions::new()
        .parens_for_negatives(true);
    
    let parens_values = vec!["($1,234.56)", "$1,234.56", "(1,234.56)", "-$1,234.56"];
    for val in parens_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(parens_options.clone())));
    }

    // Example 7: Custom decimal digits
    println!("\n7. Custom decimal digits (1 or 3 digits):");
    let custom_decimal_options = CurrencyOptions::new()
        .digits_after_decimal(vec![1, 3]);
    
    let custom_values = vec!["$10.5", "$10.123", "$10.12", "$10.1234"];
    for val in custom_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(custom_decimal_options.clone())));
    }

    println!("\n=== All examples completed ===");
}

pub fn negative_sign_after_digits(self, after: bool) -> Self

Set whether negative sign appears after digits

pub fn allow_negative_sign_placeholder(self, allow: bool) -> Self

Set whether to allow negative sign placeholder

Examples found in repository

examples/currency_usage.rs (line 44)

fn main() {
    println!("=== Currency Validator Examples ===\n");

    // Example 1: Default USD format
    println!("1. Default USD format:");
    let usd_values = vec!["$10,123.45", "10,123.45", "-$99.99", "$.99"];
    for val in usd_values {
        println!("   '{}' -> {}", val, is_currency(val, None));
    }

    // Example 2: Euro (Italian format)
    println!("\n2. Euro (Italian format - €1.234,56):");
    let euro_options = CurrencyOptions::new()
        .symbol("€")
        .thousands_separator('.')
        .decimal_separator(',')
        .allow_space_after_symbol(true);
    
    let euro_values = vec!["€1.234,56", "€ 1.234,56", "-€10,50"];
    for val in euro_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(euro_options.clone())));
    }

    // Example 3: Chinese Yuan
    println!("\n3. Chinese Yuan (¥):");
    let yuan_options = CurrencyOptions::new()
        .symbol("¥")
        .negative_sign_before_digits(true);
    
    let yuan_values = vec!["¥1,234.56", "¥-999.99", "123,456.78"];
    for val in yuan_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(yuan_options.clone())));
    }

    // Example 4: South African Rand
    println!("\n4. South African Rand (R 123 or R-123):");
    let rand_options = CurrencyOptions::new()
        .symbol("R")
        .thousands_separator(' ')
        .decimal_separator(',')
        .negative_sign_before_digits(true)
        .allow_negative_sign_placeholder(true);
    
    let rand_values = vec!["R 10 123,45", "R-10 123,45", "R 123,45"];
    for val in rand_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(rand_options.clone())));
    }

    // Example 5: Brazilian Real
    println!("\n5. Brazilian Real (R$ 1.234,56):");
    let real_options = CurrencyOptions::new()
        .symbol("R$")
        .require_symbol(true)
        .allow_space_after_symbol(true)
        .thousands_separator('.')
        .decimal_separator(',');
    
    let real_values = vec!["R$ 1.400,00", "R$ 400,00", "$ 1.400,00"];
    for val in real_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(real_options.clone())));
    }

    // Example 6: Parentheses for negatives
    println!("\n6. Parentheses for negatives:");
    let parens_options = CurrencyOptions::new()
        .parens_for_negatives(true);
    
    let parens_values = vec!["($1,234.56)", "$1,234.56", "(1,234.56)", "-$1,234.56"];
    for val in parens_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(parens_options.clone())));
    }

    // Example 7: Custom decimal digits
    println!("\n7. Custom decimal digits (1 or 3 digits):");
    let custom_decimal_options = CurrencyOptions::new()
        .digits_after_decimal(vec![1, 3]);
    
    let custom_values = vec!["$10.5", "$10.123", "$10.12", "$10.1234"];
    for val in custom_values {
        println!("   '{}' -> {}", val, is_currency(val, Some(custom_decimal_options.clone())));
    }

    println!("\n=== All examples completed ===");
}

pub fn allow_space_after_digits(self, allow: bool) -> Self

Set whether to allow space after digits

Trait Implementations

impl Clone for CurrencyOptions

fn clone(&self) -> CurrencyOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CurrencyOptions

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

Formats the value using the given formatter.

impl Default for CurrencyOptions

fn default() -> Self

Returns the “default value” for a type.