Function zigzag_encode_iter

pub fn zigzag_encode_iter<'a, T, I>(
    iter: I,
) -> impl Iterator<Item = T::UInt> + 'a
where
    T: ZigZag + Copy + 'a,
    I: Iterator<Item = &'a T> + 'a,

Creates an iterator that encodes each signed integer from the source iterator.

This function provides an iterator-based API for ZigZag encoding. The values are encoded on-the-fly as the iterator is consumed, without requiring an intermediate buffer.

Arguments

• iter - An iterator that yields references to signed integers

Returns

An iterator that yields encoded unsigned integers

Example

use zigzag_rs::{ZigZag, zigzag_encode_iter};

let values = [-10, -1, 0, 1, 10];
let encoded_iter = zigzag_encode_iter::<i32, _>(values.iter());

for (original, encoded) in values.iter().zip(encoded_iter) {
    assert_eq!(encoded, i32::zigzag_encode(*original));
}

Advanced Example

use zigzag_rs::{ZigZag, zigzag_encode_iter};

// Filtering and encoding in one pass
let values = [-100, -10, -1, 0, 1, 10, 100];
 
// Process only positive numbers
let positive_encoded: Vec<u32> = values.iter()
    .filter(|&&v| v > 0)
    .map(|&v| i32::zigzag_encode(v))
    .collect();
     
assert_eq!(positive_encoded, vec![2, 20, 200]);

// Alternative approach using zigzag_encode_iter
let positive_encoded2: Vec<u32> = zigzag_encode_iter::<i32, _>(
    values.iter().filter(|&&v| v > 0)
).collect();

assert_eq!(positive_encoded2, vec![2, 20, 200]);

Examples found in repository

examples/iterator_api.rs (line 14)

fn main() {
    println!("ZigZag Iterator-based API Examples");
    println!("================================\n");
    
    // Source data
    let values = [-100, -10, -1, 0, 1, 10, 100];
    println!("Original values: {:?}", values);
    
    // Basic encode iterator example
    println!("\n1. Basic encoding with iterator");
    println!("----------------------------");
    let encoded_iter = zigzag_encode_iter::<i32, _>(values.iter());
    
    // We can display the values as they are generated
    println!("Encoded values: ");
    for encoded in encoded_iter {
        print!("{} ", encoded);
    }
    println!();
    
    // Demonstrate conversion without allocating a buffer
    println!("\n2. Pairing original and encoded values");
    println!("----------------------------------");
    let encoded_iter = zigzag_encode_iter::<i32, _>(values.iter());
    for (original, encoded) in values.iter().zip(encoded_iter) {
        println!("{:5} encodes to {:5}", original, encoded);
    }
    
    // Decoding example
    println!("\n3. Iterator-based decoding");
    println!("------------------------");
    let encoded = [199u32, 19, 1, 0, 2, 20, 200];
    println!("Encoded values: {:?}", encoded);
    
    println!("Decoded values: ");
    let decoded_iter = zigzag_decode_iter::<i32, _>(encoded.iter());
    for decoded in decoded_iter {
        print!("{} ", decoded);
    }
    println!();
    
    // Filtering example
    println!("\n4. Combining with other iterator operations");
    println!("---------------------------------------");
    let values = [-100, -50, -10, -5, -1, 0, 1, 5, 10, 50, 100];
    
    // Create an iterator that only processes positive values
    println!("Original values: {:?}", values);
    println!("Processing only positive values:");
    
    let filtered_encoded: Vec<u32> = values.iter()
        .filter(|&&x| x > 0)  // Only positive values
        .map(|&x| i32::zigzag_encode(x))  // Encode them
        .collect();  // Collect results
    
    println!("Filtered and encoded: {:?}", filtered_encoded);
    
    // Memory efficiency example
    println!("\n5. Memory efficiency comparison");
    println!("----------------------------");
    
    // Traditional approach with intermediate allocations
    let large_range: Vec<i32> = (-1000..1000).collect();
    println!("Processing {} values", large_range.len());
    
    println!("Traditional approach (with buffer allocation):");
    let start = std::time::Instant::now();
    let mut encoded_buffer = vec![0u32; large_range.len()];
    i32::zigzag_encode_slice(&large_range, &mut encoded_buffer);
    
    let mut decoded_buffer = vec![0i32; encoded_buffer.len()];
    i32::zigzag_decode_slice(&encoded_buffer, &mut decoded_buffer);
    let duration = start.elapsed();
    println!("Time with buffers: {:?}", duration);
    
    // Iterator-based approach
    println!("Iterator-based approach:");
    let start = std::time::Instant::now();
    
    // Process without intermediate allocations
    let sum: i32 = zigzag_decode_iter::<i32, _>(
        zigzag_encode_iter::<i32, _>(large_range.iter()).collect::<Vec<_>>().iter()
    ).sum();
    
    let duration = start.elapsed();
    println!("Time with iterators: {:?}", duration);
    println!("Sum of processed values: {}", sum);
}