lopdf 0.40.0

A Rust library for PDF document manipulation.
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use lopdf::{Document, SaveOptions, Object};

fn main() {
    println!("Final Object Stream Compression Test\n");
    println!("{}", "=".repeat(60));
    
    // Create test document with various object types
    let mut doc = Document::with_version("1.5");
    
    // Add some compressible objects (fonts, annotations, etc.)
    let font1 = doc.add_object(lopdf::dictionary! {
        "Type" => "Font",
        "Subtype" => "Type1",
        "BaseFont" => "Helvetica"
    });
    
    let font2 = doc.add_object(lopdf::dictionary! {
        "Type" => "Font",
        "Subtype" => "Type1",
        "BaseFont" => "Times-Roman"
    });
    
    // Add a page (should NOT be compressed)
    let page_id = doc.add_object(lopdf::dictionary! {
        "Type" => "Page",
        "MediaBox" => vec![0.into(), 0.into(), 612.into(), 792.into()],
        "Contents" => lopdf::Object::Array(vec![]),
        "Resources" => lopdf::dictionary! {
            "Font" => lopdf::dictionary! {
                "F1" => font1,
                "F2" => font2
            }
        }
    });
    
    // Add pages tree (should NOT be compressed)
    let pages_id = doc.add_object(lopdf::dictionary! {
        "Type" => "Pages",
        "Kids" => vec![page_id.into()],
        "Count" => 1
    });
    
    // Add catalog (should NOT be compressed - it's in trailer)
    let catalog_id = doc.add_object(lopdf::dictionary! {
        "Type" => "Catalog",
        "Pages" => pages_id
    });
    
    doc.trailer.set("Root", catalog_id);
    
    // Add more compressible objects
    for i in 0..10 {
        doc.add_object(lopdf::dictionary! {
            "Type" => "Annot",
            "Subtype" => "Text",
            "Contents" => format!("Annotation {}", i)
        });
    }
    
    println!("Created test document with:");
    println!("  - 2 Font objects (should be compressed)");
    println!("  - 1 Page object (should NOT be compressed)");
    println!("  - 1 Pages object (should NOT be compressed)");
    println!("  - 1 Catalog object (should NOT be compressed)");
    println!("  - 10 Annotation objects (should be compressed)");
    
    // Save with object streams
    let options = SaveOptions {
        use_object_streams: true,
        use_xref_streams: true,
        ..Default::default()
    };
    
    let mut buffer = Vec::new();
    doc.save_with_options(&mut buffer, options).unwrap();
    
    println!("\nSaved with object streams: {} bytes", buffer.len());
    
    // Load back and analyze
    let loaded = Document::load_mem(&buffer).unwrap();
    println!("\nAnalyzing saved document:");
    println!("  Total objects: {}", loaded.objects.len());
    
    // Find object streams
    let mut obj_stream_count = 0;
    let mut compressed_count = 0;
    
    for (_id, obj) in &loaded.objects {
        if let Object::Stream(stream) = obj {
            if let Ok(type_obj) = stream.dict.get(b"Type") {
                if let Ok(type_name) = type_obj.as_name() {
                    if type_name == b"ObjStm" {
                        obj_stream_count += 1;
                        
                        // Count objects in stream
                        if let Ok(n) = stream.dict.get(b"N").and_then(|o| o.as_i64()) {
                            compressed_count += n as usize;
                        }
                    }
                }
            }
        }
    }
    
    println!("  Object streams: {}", obj_stream_count);
    println!("  Compressed objects: {}", compressed_count);
    
    // Verify critical objects are NOT compressed
    println!("\nVerifying critical objects:");
    
    // Check catalog
    if let Ok(root_ref) = loaded.trailer.get(b"Root") {
        if let Object::Reference(cat_id) = root_ref {
            check_not_compressed(&loaded, *cat_id, "Catalog");
        }
    }
    
    // Check pages tree
    if let Ok(catalog) = loaded.catalog() {
        if let Ok(pages_ref) = catalog.get(b"Pages") {
            if let Object::Reference(pages_id) = pages_ref {
                check_not_compressed(&loaded, *pages_id, "Pages tree");
            }
        }
    }
    
    // Check page objects
    let pages = loaded.get_pages();
    for (num, &page_id) in pages.iter() {
        check_not_compressed(&loaded, page_id, &format!("Page {}", num));
    }
    
    println!("\n{}", "=".repeat(60));
    println!("Test complete! Object streams are working correctly.");
}

fn check_not_compressed(doc: &Document, id: (u32, u16), name: &str) {
    if let Some(xref_entry) = doc.reference_table.get(id.0) {
        match xref_entry {
            lopdf::xref::XrefEntry::Normal { .. } => {
                println!("  ✓ {} is NOT compressed", name);
            }
            lopdf::xref::XrefEntry::Compressed { container, index } => {
                println!("  ✗ ERROR: {} is compressed in stream {} at index {}!", name, container, index);
            }
            _ => {}
        }
    }
}