quickcodes 0.1.0

Universal Barcode & QR Toolkit - Generate and read 1D and 2D codes with high performance
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

//! Code128 barcode generator

use crate::types::{Barcode, BarcodeConfig, BarcodeModules, BarcodeType, QuickCodesError, Result};

/// Generate a Code128 barcode with default configuration
pub fn generate_code128(data: &str) -> Result<Barcode> {
    generate_code128_with_config(data, &BarcodeConfig::default())
}

/// Generate a Code128 barcode with custom configuration
pub fn generate_code128_with_config(data: &str, config: &BarcodeConfig) -> Result<Barcode> {
    // For now, implement a basic Code128 Auto mode
    // This is a simplified implementation - full Code128 is quite complex

    if data.is_empty() {
        return Err(QuickCodesError::InvalidData(
            "Code128 data cannot be empty".to_string(),
        ));
    }

    // Generate a basic pattern (placeholder implementation)
    // In a full implementation, this would:
    // 1. Analyze the data to choose optimal encoding (A/B/C)
    // 2. Generate proper Code128 patterns
    // 3. Calculate check digit
    // 4. Add start/stop codes

    let pattern = generate_basic_code128_pattern(data)?;

    Ok(Barcode {
        barcode_type: BarcodeType::Code128,
        data: data.to_string(),
        modules: BarcodeModules::Linear(pattern),
        config: config.clone(),
    })
}

/// Generate a basic Code128 pattern (simplified implementation)
fn generate_basic_code128_pattern(data: &str) -> Result<Vec<bool>> {
    // This is a placeholder implementation
    // Real Code128 would need proper encoding tables and algorithms

    let mut pattern = Vec::new();

    // Start pattern (simplified)
    pattern.extend([
        true, true, false, true, false, false, true, true, false, true, false,
    ]);

    // Data encoding (very simplified - just alternating pattern based on characters)
    for (i, ch) in data.chars().enumerate() {
        let char_code = ch as u8;
        let base_pattern = match i % 3 {
            0 => [true, true, false, false, true, true, false],
            1 => [true, false, true, true, false, false, true],
            _ => [false, true, true, false, true, true, false],
        };

        // Modify pattern based on character
        for (j, &bit) in base_pattern.iter().enumerate() {
            pattern.push(bit ^ ((char_code + j as u8) % 2 == 0));
        }
    }

    // Stop pattern (simplified)
    pattern.extend([
        true, true, false, false, true, false, true, true, false, false, true,
    ]);

    Ok(pattern)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_code128_generation() {
        let result = generate_code128("Hello123");
        assert!(result.is_ok());

        let barcode = result.unwrap();
        assert_eq!(barcode.barcode_type, BarcodeType::Code128);
        assert_eq!(barcode.data, "Hello123");

        match barcode.modules {
            BarcodeModules::Linear(pattern) => {
                assert!(!pattern.is_empty());
            }
            _ => panic!("Code128 should generate a linear pattern"),
        }
    }

    #[test]
    fn test_code128_empty_data() {
        let result = generate_code128("");
        assert!(result.is_err());
    }
}