lopdf 0.41.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

use lopdf::{Document, Object, ObjectStream, dictionary};

#[cfg(feature = "async")]
use tokio::runtime::Builder;

#[cfg(not(feature = "async"))]
fn load_document(path: &str) -> Document {
    Document::load(path).unwrap()
}

#[cfg(feature = "async")]
fn load_document(path: &str) -> Document {
    Builder::new_current_thread()
        .enable_all()
        .build()
        .unwrap()
        .block_on(async move { Document::load(path).await.unwrap() })
}

fn main() {
    println!("Testing direct object stream creation and saving...\n");

    // Create a simple document
    let mut doc = Document::with_version("1.5");

    // Create an object stream manually
    let mut obj_stream = ObjectStream::builder().max_objects(10).compression_level(6).build();

    // Add some objects
    obj_stream.add_object((1, 0), Object::Integer(42)).unwrap();
    obj_stream
        .add_object((2, 0), Object::String(b"Test".to_vec(), lopdf::StringFormat::Literal))
        .unwrap();

    println!("Object stream has {} objects", obj_stream.object_count());

    // Convert to stream object
    let stream_obj = obj_stream.to_stream_object().unwrap();
    println!("Stream dict: {:?}", stream_obj.dict);
    println!("Stream has Filter: {}", stream_obj.dict.get(b"Filter").is_ok());

    // Add it to the document
    let stream_id = doc.add_object(stream_obj);
    println!("Added object stream as {} 0 R", stream_id.0);

    // Add a simple catalog
    let pages_id = doc.add_object(dictionary! {
        "Type" => "Pages",
        "Kids" => vec![],
        "Count" => 0
    });

    let catalog_id = doc.add_object(dictionary! {
        "Type" => "Catalog",
        "Pages" => pages_id
    });

    doc.trailer.set("Root", catalog_id);

    // Save the document
    println!("\nSaving document...");
    doc.save("test_direct_objstream.pdf").unwrap();

    println!("Saved to test_direct_objstream.pdf");

    // Load it back and check
    println!("\nLoading back...");
    let loaded = load_document("test_direct_objstream.pdf");

    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" {
                        println!("Found object stream {} 0 R", id.0);
                        println!("  Dict: {:?}", stream.dict);
                        println!("  Has Filter: {}", stream.dict.get(b"Filter").is_ok());
                        if let Ok(filter) = stream.dict.get(b"Filter") {
                            println!("  Filter value: {:?}", filter);
                        }
                    }
                }
            }
        }
    }
}