neocrates 0.1.47

A comprehensive Rust library for various utilities and helpers
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

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ParseResult {
    pub page: u32,
    pub bbox: (f32, f32, f32, f32),
    pub typeid: u32,
    pub size: (f32, f32),
    pub text: String,
}

/// Merges ParseResult entries into chunks not exceeding max_len characters.
pub fn smart_chunks(results: Vec<ParseResult>, max_len: usize) -> Vec<ParseResult> {
    let mut merged_results = Vec::new();
    let mut buffer = String::new();
    let mut last_page = 0;
    let mut last_bbox = (0.0, 0.0, 0.0, 0.0);
    let mut last_typeid = 0;
    let mut last_size = (0.0, 0.0);

    for result in results {
        let mut text = result.text;
        while text.chars().count() > max_len {
            let segment: String = text.chars().take(max_len).collect();
            if !buffer.is_empty() {
                merged_results.push(ParseResult {
                    page: last_page,
                    bbox: last_bbox,
                    typeid: last_typeid,
                    size: last_size,
                    text: buffer.clone(),
                });
                buffer.clear();
            }
            merged_results.push(ParseResult {
                page: result.page,
                bbox: result.bbox,
                typeid: result.typeid,
                size: result.size,
                text: segment,
            });
            text = text.chars().skip(max_len).collect();
        }

        if buffer.chars().count() + text.chars().count() > max_len {
            if !buffer.is_empty() {
                merged_results.push(ParseResult {
                    page: last_page,
                    bbox: last_bbox,
                    typeid: last_typeid,
                    size: last_size,
                    text: buffer.clone(),
                });
                buffer.clear();
            }
        }
        if !text.is_empty() {
            if buffer.is_empty() {
                last_page = result.page;
                last_bbox = result.bbox;
                last_typeid = result.typeid;
                last_size = result.size;
            }
            buffer.push_str(&text);
        }
    }

    if !buffer.is_empty() {
        merged_results.push(ParseResult {
            page: last_page,
            bbox: last_bbox,
            typeid: last_typeid,
            size: last_size,
            text: buffer,
        });
    }

    merged_results
}

//let new_vec = smart_merge_parse_results(result, 512);