rust-assembler 0.1.101

/// Replaces multiple `str` at once, avoiding intermediate allocations. It returns a new `String` containing the result. Values passed by value keep ownership.
/// 
/// # Examples
/// 
/// ```
/// 
/// let s = "Ciao bello";
/// 
/// let s_replaced = replace_str!( s;
///     ["ia", "u"],
///     ["ll", ""]
/// );
/// 
/// assert_eq!(s_replaced, "Cuo beo");
#[macro_export]
macro_rules! replace_str {
    ( $string:expr; $( $pair:expr ),* ) => ({
        let mut new_string: String = String::new();

        let mut to_skip = 0;
        let mut next_start = 0;
        
        'outer: for i in 0..$string.len() {
            if to_skip > 0 {
                to_skip -= 1;
                continue 'outer
            }

            $(
                unsafe {
                    // It's the element that must be replaced.
                    let elm_0 = *$pair.get_unchecked(0);
                    
                    let elm_0_len = elm_0.len();
                    // Avoids out of bounds bugs.
                    if i + elm_0_len > $string.len() { break 'outer }

                    // First compares the first character..
                    if *elm_0.as_bytes().get_unchecked(0) == *$string.as_bytes().get_unchecked(i) {
                        // .. then the whole string.
                        if *elm_0 == *$string.get_unchecked(i..i + elm_0_len) {
                            extend_string!( new_string;
                                $string.get_unchecked(next_start..i),
                                $pair.get_unchecked(1)
                            );
                            next_start = i + elm_0_len;
                            to_skip += elm_0_len - 1;
                        }
                    }
                }
            )*
            
        }
        
        unsafe {
            new_string.push_str($string.get_unchecked(next_start..));
        }

        new_string
    });
}