pdfcrate 0.1.1

A Rust library for creating and manipulating PDF documents
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

//! PDF Number object
//!
//! PDF supports two numeric types: integers and real numbers.

use std::fmt;

/// A PDF number (integer or real)
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum PdfNumber {
    /// Integer number
    Integer(i64),
    /// Real (floating-point) number
    Real(f64),
}

impl PdfNumber {
    /// Creates a new integer number
    pub fn integer(value: i64) -> Self {
        PdfNumber::Integer(value)
    }

    /// Creates a new real number
    pub fn real(value: f64) -> Self {
        PdfNumber::Real(value)
    }

    /// Returns the value as an integer, truncating if real
    pub fn as_integer(&self) -> i64 {
        match self {
            PdfNumber::Integer(i) => *i,
            PdfNumber::Real(r) => *r as i64,
        }
    }

    /// Returns the value as a real number
    pub fn as_real(&self) -> f64 {
        match self {
            PdfNumber::Integer(i) => *i as f64,
            PdfNumber::Real(r) => *r,
        }
    }

    /// Returns true if this is an integer
    pub fn is_integer(&self) -> bool {
        matches!(self, PdfNumber::Integer(_))
    }

    /// Returns true if this is a real number
    pub fn is_real(&self) -> bool {
        matches!(self, PdfNumber::Real(_))
    }
}

impl fmt::Display for PdfNumber {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            PdfNumber::Integer(i) => write!(f, "{}", i),
            PdfNumber::Real(r) => {
                // Format real numbers efficiently
                if r.fract() == 0.0 && r.abs() < i64::MAX as f64 {
                    write!(f, "{:.1}", r)
                } else {
                    // Use enough precision but avoid excessive digits
                    let s = format!("{:.6}", r);
                    let trimmed = s.trim_end_matches('0').trim_end_matches('.');
                    if trimmed.is_empty() || trimmed == "-" {
                        write!(f, "0")
                    } else {
                        write!(f, "{}", trimmed)
                    }
                }
            }
        }
    }
}

impl From<i32> for PdfNumber {
    fn from(value: i32) -> Self {
        PdfNumber::Integer(value as i64)
    }
}

impl From<i64> for PdfNumber {
    fn from(value: i64) -> Self {
        PdfNumber::Integer(value)
    }
}

impl From<f32> for PdfNumber {
    fn from(value: f32) -> Self {
        PdfNumber::Real(value as f64)
    }
}

impl From<f64> for PdfNumber {
    fn from(value: f64) -> Self {
        PdfNumber::Real(value)
    }
}

impl From<usize> for PdfNumber {
    fn from(value: usize) -> Self {
        PdfNumber::Integer(value as i64)
    }
}

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

    #[test]
    fn test_integer() {
        let n = PdfNumber::integer(42);
        assert!(n.is_integer());
        assert_eq!(n.as_integer(), 42);
        assert_eq!(format!("{}", n), "42");
    }

    #[test]
    fn test_real() {
        let n = PdfNumber::real(1.23456);
        assert!(n.is_real());
        assert!((n.as_real() - 1.23456).abs() < 0.00001);
        assert_eq!(format!("{}", n), "1.23456");
    }

    #[test]
    fn test_real_without_fraction() {
        let n = PdfNumber::real(42.0);
        assert_eq!(format!("{}", n), "42.0");
    }

    #[test]
    fn test_conversion() {
        let n: PdfNumber = 42i32.into();
        assert!(n.is_integer());

        let n: PdfNumber = 2.73f64.into();
        assert!(n.is_real());
    }
}