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

use std::collections::HashMap;
use istring::SmallString;
use crate as pdf;
use crate::object::{Object, Resolve, ObjectWrite, DeepClone};
use crate::primitive::{Primitive, Dictionary};
use crate::error::{Result};
use datasize::DataSize;

#[derive(Debug, Clone, DataSize)]
pub struct Encoding {
    pub base: BaseEncoding,
    pub differences: HashMap<u32, SmallString>,
}

#[derive(Object, ObjectWrite, Debug, Clone, Eq, PartialEq, DataSize)]
pub enum BaseEncoding {
    StandardEncoding,
    SymbolEncoding,
    MacRomanEncoding,
    WinAnsiEncoding,
    MacExpertEncoding,
    #[pdf(name = "Identity-H")]
    IdentityH,
    None,

    #[pdf(other)]
    Other(String),
}
impl Object for Encoding {
    fn from_primitive(p: Primitive, resolve: &impl Resolve) -> Result<Self> {
        match p {
            name @ Primitive::Name(_) => { 
                Ok(Encoding {
                base: BaseEncoding::from_primitive(name, resolve)?,
                differences: HashMap::new(),
                })
            }
            Primitive::Dictionary(mut dict) => {
                let base = match dict.remove("BaseEncoding") {
                    Some(p) => BaseEncoding::from_primitive(p, resolve)?,
                    None => BaseEncoding::None
                };
                let mut gid = 0;
                let mut differences = HashMap::new();
                if let Some(p) = dict.remove("Differences") {
                    for part in p.resolve(resolve)?.into_array()? {
                        match part {
                            Primitive::Integer(code) => {
                                gid = code as u32;
                            }
                            Primitive::Name(name) => {
                                differences.insert(gid, name);
                                gid += 1;
                            }
                            _ => bail!("Unknown part primitive in dictionary: {:?}", part),
                        }
                    }
                }
                Ok(Encoding { base, differences })
            }
            Primitive::Reference(r) => Self::from_primitive(resolve.resolve(r)?, resolve),
            Primitive::Stream(s) => Self::from_primitive(Primitive::Dictionary(s.info), resolve),
            _ => bail!("Unknown element: {:?}", p),
        }
    }
}
impl ObjectWrite for Encoding {
    fn to_primitive(&self, update: &mut impl pdf::object::Updater) -> Result<Primitive> {
        let base = self.base.to_primitive(update)?;
        if self.differences.len() == 0 {
            Ok(base)
        } else {
            let mut list = vec![];

            let mut diff_list: Vec<_> = self.differences.iter().collect();
            diff_list.sort();
            let mut last = None;

            for &(&gid, name) in diff_list.iter() {
                if !last.map(|n| n + 1 == gid).unwrap_or(false) {
                    list.push(Primitive::Integer(gid as i32));
                }

                list.push(Primitive::Name(name.clone()));

                last = Some(gid);
            }

            let mut dict = Dictionary::new();
            dict.insert("BaseEncoding", base);
            dict.insert("Differences", Primitive::Array(list));
            Ok(Primitive::Dictionary(dict))
        }
    }
}
impl Encoding {
    pub fn standard() -> Encoding {
        Encoding {
            base: BaseEncoding::StandardEncoding,
            differences: HashMap::new()
        }
    }
}
impl DeepClone for Encoding {
    fn deep_clone(&self, cloner: &mut impl pdf::object::Cloner) -> Result<Self> {
        Ok(self.clone())
    }
}