pdf/object/
mod.rs

1//! `Object` trait, along with some implementations. References.
2//!
3//! Some of the structs are incomplete (missing fields that are in the PDF references).
4
5mod types;
6mod stream;
7mod color;
8mod function;
9
10pub use self::types::*;
11pub use self::stream::*;
12pub use self::color::*;
13pub use self::function::*;
14pub use crate::file::PromisedRef;
15use crate::parser::ParseFlags;
16
17use crate::primitive::*;
18use crate::error::*;
19use crate::enc::*;
20
21use std::fmt;
22use std::marker::PhantomData;
23use std::collections::HashMap;
24use std::sync::Arc;
25use std::ops::{Deref, Range};
26use std::hash::{Hash, Hasher};
27use std::convert::TryInto;
28use datasize::DataSize;
29use itertools::Itertools;
30use once_cell::sync::OnceCell;
31
32pub type ObjNr = u64;
33pub type GenNr = u64;
34
35pub struct ParseOptions {
36    pub allow_error_in_option: bool,
37    pub allow_xref_error: bool,
38    pub allow_invalid_ops: bool,
39    pub allow_missing_endobj: bool,
40}
41impl ParseOptions {
42    pub const fn tolerant() -> Self {
43        ParseOptions {
44            allow_error_in_option: true,
45            allow_xref_error: true,
46            allow_invalid_ops: true,
47            allow_missing_endobj: true,
48        }
49    }
50    pub const fn strict() -> Self {
51        ParseOptions {
52            allow_error_in_option: false,
53            allow_xref_error: false,
54            allow_invalid_ops: true,
55            allow_missing_endobj: false,
56        }
57    }
58}
59
60pub trait Resolve: {
61    fn resolve_flags(&self, r: PlainRef, flags: ParseFlags, depth: usize) -> Result<Primitive>;
62    fn resolve(&self, r: PlainRef) -> Result<Primitive> {
63        self.resolve_flags(r, ParseFlags::ANY, 16)
64    }
65    fn get<T: Object+DataSize>(&self, r: Ref<T>) -> Result<RcRef<T>>;
66    fn options(&self) -> &ParseOptions;
67    fn stream_data(&self, id: PlainRef, range: Range<usize>) -> Result<Arc<[u8]>>;
68    fn get_data_or_decode(&self, id: PlainRef, range: Range<usize>, filters: &[StreamFilter]) -> Result<Arc<[u8]>>;
69}
70
71pub struct NoResolve;
72impl Resolve for NoResolve {
73    fn resolve_flags(&self, _: PlainRef, _: ParseFlags, _: usize) -> Result<Primitive> {
74        Err(PdfError::Reference)
75    }
76    fn get<T: Object+DataSize>(&self, _r: Ref<T>) -> Result<RcRef<T>> {
77        Err(PdfError::Reference)
78    }
79    fn options(&self) -> &ParseOptions {
80        static STRICT: ParseOptions = ParseOptions::strict();
81        &STRICT
82    }
83    fn get_data_or_decode(&self, _: PlainRef, _: Range<usize>, _: &[StreamFilter]) -> Result<Arc<[u8]>> {
84        Err(PdfError::Reference)
85    }
86    fn stream_data(&self, id: PlainRef, range: Range<usize>) -> Result<Arc<[u8]>> {
87        Err(PdfError::Reference)
88    }
89
90}
91
92/// A PDF Object
93pub trait Object: Sized + Sync + Send + 'static {
94    /// Convert primitive to Self
95    fn from_primitive(p: Primitive, resolve: &impl Resolve) -> Result<Self>;
96}
97
98pub trait Cloner: Updater + Resolve {
99    fn clone_plainref(&mut self, old: PlainRef) -> Result<PlainRef>;
100    fn clone_ref<T: DeepClone + Object + DataSize + ObjectWrite>(&mut self, old: Ref<T>) -> Result<Ref<T>>;
101    fn clone_rcref<T: DeepClone + ObjectWrite + DataSize>(&mut self, old: &RcRef<T>) -> Result<RcRef<T>>;
102    fn clone_shared<T: DeepClone>(&mut self, old: &Shared<T>) -> Result<Shared<T>>;
103}
104
105pub trait DeepClone: Sized + Sync + Send + 'static {
106    fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self>;
107}
108
109pub trait Updater {
110    fn create<T: ObjectWrite>(&mut self, obj: T) -> Result<RcRef<T>>;
111    fn update<T: ObjectWrite>(&mut self, old: PlainRef, obj: T) -> Result<RcRef<T>>;
112    fn promise<T: Object>(&mut self) -> PromisedRef<T>;
113    fn fulfill<T: ObjectWrite>(&mut self, promise: PromisedRef<T>, obj: T) -> Result<RcRef<T>>;
114}
115
116pub struct NoUpdate;
117impl Updater for NoUpdate {
118    fn create<T: ObjectWrite>(&mut self, _obj: T) -> Result<RcRef<T>> { panic!() }
119    fn update<T: ObjectWrite>(&mut self, _old: PlainRef, _obj: T) -> Result<RcRef<T>> { panic!() }
120    fn promise<T: Object>(&mut self) -> PromisedRef<T> { panic!() }
121    fn fulfill<T: ObjectWrite>(&mut self, _promise: PromisedRef<T>, _obj: T) -> Result<RcRef<T>> { panic!() }
122}
123
124pub trait ObjectWrite {
125    fn to_primitive(&self, update: &mut impl Updater) -> Result<Primitive>;
126}
127
128pub trait FromDict: Sized {
129    fn from_dict(dict: Dictionary, resolve: &impl Resolve) -> Result<Self>;
130}
131pub trait ToDict: ObjectWrite {
132    fn to_dict(&self, update: &mut impl Updater) -> Result<Dictionary>;
133}
134
135pub trait SubType<T> {}
136
137pub trait Trace {
138    fn trace(&self, _cb: &mut impl FnMut(PlainRef)) {}
139}
140
141///////
142// Refs
143///////
144
145// TODO move to primitive.rs
146#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, DataSize)]
147pub struct PlainRef {
148    pub id:     ObjNr,
149    pub gen:    GenNr,
150}
151impl Object for PlainRef {
152    fn from_primitive(p: Primitive, _: &impl Resolve) -> Result<Self> {
153        p.into_reference()
154    }
155}
156impl ObjectWrite for PlainRef {
157    fn to_primitive(&self, _: &mut impl Updater) -> Result<Primitive> {
158        Ok(Primitive::Reference(*self))
159    }
160}
161impl DeepClone for PlainRef {
162    fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self> {
163        cloner.clone_plainref(*self)
164    }
165}
166
167// NOTE: Copy & Clone implemented manually ( https://github.com/rust-lang/rust/issues/26925 )
168
169#[derive(DataSize)]
170pub struct Ref<T> {
171    inner:      PlainRef,
172    _marker:    PhantomData<T>
173}
174impl<T> Clone for Ref<T> {
175    fn clone(&self) -> Ref<T> {
176        *self
177    }
178}
179impl<T> Copy for Ref<T> {}
180
181impl<T> Ref<T> {
182    pub fn new(inner: PlainRef) -> Ref<T> {
183        Ref {
184            inner,
185            _marker:    PhantomData,
186        }
187    }
188    pub fn from_id(id: ObjNr) -> Ref<T> {
189        Ref {
190            inner:      PlainRef {id, gen: 0},
191            _marker:    PhantomData,
192        }
193    }
194    pub fn get_inner(&self) -> PlainRef {
195        self.inner
196    }
197    pub fn upcast<U>(self) -> Ref<U> where T: SubType<U> {
198        Ref::new(self.inner)
199    }
200}
201impl<T: Object> Object for Ref<T> {
202    fn from_primitive(p: Primitive, _: &impl Resolve) -> Result<Self> {
203        Ok(Ref::new(p.into_reference()?))
204    }
205}
206impl<T> ObjectWrite for Ref<T> {
207    fn to_primitive(&self, update: &mut impl Updater) -> Result<Primitive> {
208        self.inner.to_primitive(update)
209    }
210}
211impl<T: DeepClone+Object+DataSize+ObjectWrite> DeepClone for Ref<T> {
212    fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self> {
213        cloner.clone_ref(*self)
214    }
215}
216impl<T> Trace for Ref<T> {
217    fn trace(&self, cb: &mut impl FnMut(PlainRef)) {
218        cb(self.inner);
219    }
220}
221impl<T> fmt::Debug for Ref<T> {
222    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
223        write!(f, "Ref({})", self.inner.id)
224    }
225}
226impl<T> Hash for Ref<T> {
227    fn hash<H: Hasher>(&self, state: &mut H) {
228        self.inner.hash(state)
229    }
230}
231impl<T> PartialEq for Ref<T> {
232    fn eq(&self, rhs: &Self) -> bool {
233        self.inner.eq(&rhs.inner)
234    }
235}
236impl<T> Eq for Ref<T> {}
237
238pub type Shared<T> = Arc<T>;
239
240
241#[derive(Debug, DataSize)]
242pub struct RcRef<T> {
243    inner: PlainRef,
244    data: Shared<T>
245}
246impl<T> From<RcRef<T>> for Primitive {
247    fn from(value: RcRef<T>) -> Self {
248        Primitive::Reference(value.inner)
249    }
250}
251impl<T> From<RcRef<T>> for Ref<T> {
252    fn from(value: RcRef<T>) -> Self {
253        value.get_ref()
254    }
255}
256
257impl<T> RcRef<T> {
258    pub fn new(inner: PlainRef, data: Shared<T>) -> RcRef<T> {
259        RcRef { inner, data }
260    }
261    pub fn get_ref(&self) -> Ref<T> {
262        Ref::new(self.inner)
263    }
264    pub fn data(&self) -> &Shared<T> {
265        &self.data
266    }
267}
268impl<T: Object + std::fmt::Debug + DataSize> Object for RcRef<T> {
269    fn from_primitive(p: Primitive, resolve: &impl Resolve) -> Result<Self> {
270        match p {
271            Primitive::Reference(r) => resolve.get(Ref::new(r)),
272            p => Err(PdfError::UnexpectedPrimitive {expected: "Reference", found: p.get_debug_name()})
273        }
274    }
275}
276impl<T> ObjectWrite for RcRef<T> {
277    fn to_primitive(&self, update: &mut impl Updater) -> Result<Primitive> {
278        self.inner.to_primitive(update)
279    }
280}
281impl<T: DeepClone + std::fmt::Debug + DataSize + Object + ObjectWrite> DeepClone for RcRef<T> {
282    fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self> {
283        cloner.clone_rcref(self)
284    }
285}
286
287impl<T> Deref for RcRef<T> {
288    type Target = T;
289    fn deref(&self) -> &T {
290        &self.data
291    }
292}
293impl<T> Clone for RcRef<T> {
294    fn clone(&self) -> RcRef<T> {
295        RcRef {
296            inner: self.inner,
297            data: self.data.clone(),
298        }
299    }
300}
301impl<T> Trace for RcRef<T> {
302    fn trace(&self, cb: &mut impl FnMut(PlainRef)) {
303        cb(self.inner);
304    }
305}
306impl<'a, T> From<&'a RcRef<T>> for Ref<T> {
307    fn from(r: &'a RcRef<T>) -> Ref<T> {
308        Ref::new(r.inner)
309    }
310}
311impl<T> Hash for RcRef<T> {
312    fn hash<H: Hasher>(&self, state: &mut H) {
313        std::ptr::hash(&**self, state)
314    }
315}
316impl<T> PartialEq for RcRef<T> {
317    fn eq(&self, rhs: &Self) -> bool {
318        std::ptr::eq(&**self, &**rhs)
319    }
320}
321impl<T> Eq for RcRef<T> {}
322
323#[derive(Debug, DataSize)]
324pub enum MaybeRef<T> {
325    Direct(Shared<T>),
326    Indirect(RcRef<T>),
327}
328impl<T> MaybeRef<T> {
329    pub fn as_ref(&self) -> Option<Ref<T>> {
330        match *self {
331            MaybeRef::Indirect(ref r) => Some(r.get_ref()),
332            _ => None
333        }
334    }
335    pub fn data(&self) -> &Shared<T> {
336        match *self {
337            MaybeRef::Direct(ref t) => t,
338            MaybeRef::Indirect(ref r) => &r.data
339        }
340    }
341}
342impl<T: Object+DataSize> Object for MaybeRef<T> {
343    fn from_primitive(p: Primitive, resolve: &impl Resolve) -> Result<Self> {
344        Ok(match p {
345            Primitive::Reference(r) => MaybeRef::Indirect(resolve.get(Ref::new(r))?),
346            p => MaybeRef::Direct(Shared::new(T::from_primitive(p, resolve)?))
347        })
348    }
349}
350impl<T: ObjectWrite> ObjectWrite for MaybeRef<T> {
351    fn to_primitive(&self, update: &mut impl Updater) -> Result<Primitive> {
352        match self {
353            MaybeRef::Direct(ref inner) => inner.to_primitive(update),
354            MaybeRef::Indirect(r) => r.to_primitive(update)
355        }
356    }
357}
358impl<T: DeepClone + std::fmt::Debug + DataSize + Object + ObjectWrite> DeepClone for MaybeRef<T> {
359    fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self> {
360        match *self {
361            MaybeRef::Direct(ref old) => cloner.clone_shared(old).map(MaybeRef::Direct),
362            MaybeRef::Indirect(ref old) => cloner.clone_rcref(old).map(MaybeRef::Indirect)
363        }
364    }
365}
366impl<T> Deref for MaybeRef<T> {
367    type Target = T;
368    fn deref(&self) -> &T {
369        match *self {
370            MaybeRef::Direct(ref t) => t,
371            MaybeRef::Indirect(ref r) => r
372        }
373    }
374}
375impl<T> Clone for MaybeRef<T> {
376    fn clone(&self) -> Self {
377        match *self {
378            MaybeRef::Direct(ref rc) => MaybeRef::Direct(rc.clone()),
379            MaybeRef::Indirect(ref r) => MaybeRef::Indirect(r.clone())
380        }
381    }
382}
383impl<T> Trace for MaybeRef<T> {
384    fn trace(&self, cb: &mut impl FnMut(PlainRef)) {
385        match *self {
386            MaybeRef::Indirect(ref rc) => rc.trace(cb),
387            MaybeRef::Direct(_) => ()
388        }
389    }
390}
391impl<T> From<Shared<T>> for MaybeRef<T> {
392    fn from(r: Shared<T>) -> MaybeRef<T> {
393        MaybeRef::Direct(r)
394    }
395}
396impl<T> From<T> for MaybeRef<T> {
397    fn from(t: T) -> MaybeRef<T> {
398        MaybeRef::Direct(t.into())
399    }
400}
401impl<T> From<MaybeRef<T>> for Shared<T> {
402    fn from(r: MaybeRef<T>) -> Shared<T> {
403        match r {
404            MaybeRef::Direct(rc) => rc,
405            MaybeRef::Indirect(r) => r.data
406        }
407    }
408}
409impl<'a, T> From<&'a MaybeRef<T>> for Shared<T> {
410    fn from(r: &'a MaybeRef<T>) -> Shared<T> {
411        match r {
412            MaybeRef::Direct(ref rc) => rc.clone(),
413            MaybeRef::Indirect(ref r) => r.data.clone()
414        }
415    }
416}
417impl<T> From<RcRef<T>> for MaybeRef<T> {
418    fn from(r: RcRef<T>) -> MaybeRef<T> {
419        MaybeRef::Indirect(r)
420    }
421}
422impl<T> Hash for MaybeRef<T> {
423    fn hash<H: Hasher>(&self, state: &mut H) {
424        std::ptr::hash(&**self, state)
425    }
426}
427impl<T> PartialEq for MaybeRef<T> {
428    fn eq(&self, rhs: &Self) -> bool {
429        std::ptr::eq(&**self, &**rhs)
430    }
431}
432impl<T> Eq for MaybeRef<T> {}
433
434#[derive(Debug)]
435pub struct Lazy<T> {
436    primitive: Primitive,
437    cache: OnceCell<MaybeRef<T>>,
438    _marker: PhantomData<T>
439}
440impl<T: DataSize> DataSize for Lazy<T> {
441    const IS_DYNAMIC: bool = true;
442    const STATIC_HEAP_SIZE: usize = size_of::<Self>();
443    fn estimate_heap_size(&self) -> usize {
444        self.cache.get().map(|value| value.estimate_heap_size()).unwrap_or(0) + size_of::<Self>()
445    }
446}
447impl<T> Clone for Lazy<T> {
448    fn clone(&self) -> Self {
449        Lazy {
450            primitive: self.primitive.clone(),
451            cache: self.cache.clone(),
452            _marker: PhantomData
453        }
454    }
455}
456impl<T: Object> DeepClone for Lazy<T> {
457    fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self> {
458        Ok(Lazy {
459            primitive: self.primitive.deep_clone(cloner)?,
460            cache: OnceCell::new(),
461            _marker: PhantomData
462        })
463    }
464}
465impl<T: Object + DataSize> Lazy<T> {
466    pub fn load(&self, resolve: &impl Resolve) -> Result<MaybeRef<T>> {
467        self.cache.get_or_try_init(|| {
468            match self.primitive {
469                Primitive::Reference(r) => resolve.get(Ref::new(r)).map(MaybeRef::Indirect),
470                ref p => T::from_primitive(p.clone(), resolve).map(|o| MaybeRef::Direct(Arc::new(o))),
471            }
472        }).cloned()
473    }
474}
475impl<T: Object> Object for Lazy<T> {
476    fn from_primitive(p: Primitive, _: &impl Resolve) -> Result<Self> {
477        Ok(Self {
478            primitive: p,
479            cache: OnceCell::new(),
480            _marker: PhantomData
481        })
482    }
483}
484impl<T: ObjectWrite> ObjectWrite for Lazy<T> {
485    fn to_primitive(&self, update: &mut impl Updater) -> Result<Primitive> {
486        Ok(self.primitive.clone())
487    }
488}
489impl<T> Default for Lazy<T> {
490    fn default() -> Self {
491        Lazy {
492            primitive: Primitive::Null,
493            cache: OnceCell::new(),
494            _marker: PhantomData
495        }
496    }
497}
498impl<T: Object> From<RcRef<T>> for Lazy<T> {
499    fn from(value: RcRef<T>) -> Self {
500        Lazy {
501            primitive: Primitive::Reference(value.inner),
502            cache: OnceCell::with_value(MaybeRef::Direct(value.data)),
503            _marker: PhantomData
504        }
505    }
506}
507
508//////////////////////////////////////
509// Object for Primitives & other types
510//////////////////////////////////////
511
512impl Object for i32 {
513    fn from_primitive(p: Primitive, r: &impl Resolve) -> Result<Self> {
514        match p {
515            Primitive::Reference(id) => r.resolve(id)?.as_integer(),
516            p => p.as_integer()
517        }
518    }
519}
520impl ObjectWrite for i32 {
521    fn to_primitive(&self, _: &mut impl Updater) -> Result<Primitive> {
522        Ok(Primitive::Integer(*self))
523    }
524}
525
526impl Object for u32 {
527    fn from_primitive(p: Primitive, r: &impl Resolve) -> Result<Self> {
528        match p {
529            Primitive::Reference(id) => r.resolve(id)?.as_u32(),
530            p => p.as_u32()
531        }
532    }
533}
534impl ObjectWrite for u32 {
535    fn to_primitive(&self, _: &mut impl Updater) -> Result<Primitive> {
536        Ok(Primitive::Integer(*self as _))
537    }
538}
539
540impl Object for usize {
541    fn from_primitive(p: Primitive, r: &impl Resolve) -> Result<Self> {
542        match p {
543            Primitive::Reference(id) => Ok(r.resolve(id)?.as_u32()? as usize),
544            p => Ok(p.as_u32()? as usize)
545        }
546    }
547}
548impl ObjectWrite for usize {
549    fn to_primitive(&self, _: &mut impl Updater) -> Result<Primitive> {
550        Ok(Primitive::Integer(*self as _))
551    }
552}
553
554impl Object for f32 {
555    fn from_primitive(p: Primitive, r: &impl Resolve) -> Result<Self> {
556        match p {
557            Primitive::Reference(id) => r.resolve(id)?.as_number(),
558            p => p.as_number()
559        }
560    }
561}
562impl ObjectWrite for f32 {
563    fn to_primitive(&self, _: &mut impl Updater) -> Result<Primitive> {
564        Ok(Primitive::Number(*self))
565    }
566}
567
568impl Object for bool {
569    fn from_primitive(p: Primitive, r: &impl Resolve) -> Result<Self> {
570        match p {
571            Primitive::Reference(id) => r.resolve(id)?.as_bool(),
572            p => p.as_bool()
573        }
574    }
575}
576impl ObjectWrite for bool {
577    fn to_primitive(&self, _: &mut impl Updater) -> Result<Primitive> {
578        Ok(Primitive::Boolean(*self))
579    }
580}
581
582impl Object for Dictionary {
583    fn from_primitive(p: Primitive, r: &impl Resolve) -> Result<Self> {
584        match p {
585            Primitive::Dictionary(dict) => Ok(dict),
586            Primitive::Reference(id) => Dictionary::from_primitive(r.resolve(id)?, r),
587            _ => Err(PdfError::UnexpectedPrimitive {expected: "Dictionary", found: p.get_debug_name()}),
588        }
589    }
590}
591
592impl Object for Name {
593    fn from_primitive(p: Primitive, resolve: &impl Resolve) -> Result<Self> {
594        p.resolve(resolve)?.into_name()
595    }
596}
597impl ObjectWrite for Name {
598    fn to_primitive(&self, _: &mut impl Updater) -> Result<Primitive> {
599        Ok(Primitive::Name(self.0.clone()))
600    }
601}
602
603impl<T: Object> Object for Vec<T> {
604    /// Will try to convert `p` to `T` first, then try to convert `p` to Vec<T>
605    fn from_primitive(p: Primitive, r: &impl Resolve) -> Result<Self> {
606        Ok(
607        match p {
608            Primitive::Array(_) => {
609                p.resolve(r)?.into_array()?
610                    .into_iter()
611                    .map(|p| T::from_primitive(p, r))
612                    .collect::<Result<Vec<T>>>()?
613            },
614            Primitive::Null => {
615                Vec::new()
616            }
617            Primitive::Reference(id) => Self::from_primitive(r.resolve(id)?, r)?,
618            _ => vec![T::from_primitive(p, r)?]
619        }
620        )
621    }
622}
623impl<T: ObjectWrite> ObjectWrite for Vec<T> {
624    fn to_primitive(&self, update: &mut impl Updater) -> Result<Primitive> {
625        Primitive::array::<T, _, _, _>(self.iter(), update)
626    }
627}
628impl<T: DeepClone> DeepClone for Vec<T> {
629    fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self> {
630        self.iter().map(|t| t.deep_clone(cloner)).collect()
631    }
632}
633impl<T: Trace> Trace for Vec<T> {
634    fn trace(&self, cb: &mut impl FnMut(PlainRef)) {
635        for i in self.iter() {
636            i.trace(cb);
637        }
638    }
639}
640/*
641pub struct Data(pub Vec<u8>);
642impl Object for Data {
643    fn serialize<W: io::Write>(&self, out: &mut W) -> Result<()> {
644        unimplemented!()
645    }
646    /// Will try to convert `p` to `T` first, then try to convert `p` to Vec<T>
647    fn from_primitive(p: Primitive, r: &impl Resolve) -> Result<Self> {
648        match p {
649            Primitive::Array(_) => {
650                p.into_array(r)?
651                    .into_iter()
652                    .map(|p| u8::from_primitive(p, r))
653                    .collect::<Result<Vec<T>>>()?
654            },
655            Primitive::Null => {
656                Vec::new()
657            }
658            Primitive::Reference(id) => Self::from_primitive(r.resolve(id)?, r)?,
659            _ => 
660        }
661    }
662}*/
663
664impl Object for Primitive {
665    fn from_primitive(p: Primitive, _: &impl Resolve) -> Result<Self> {
666        Ok(p)
667    }
668}
669impl ObjectWrite for Primitive {
670    fn to_primitive(&self, _: &mut impl Updater) -> Result<Primitive> {
671        Ok(self.clone())
672    }
673}
674impl DeepClone for Primitive {
675    fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self> {
676        match *self {
677            Primitive::Array(ref parts) => Ok(Primitive::Array(parts.into_iter().map(|p| p.deep_clone(cloner)).try_collect()?)),
678            Primitive::Boolean(b) => Ok(Primitive::Boolean(b)),
679            Primitive::Dictionary(ref dict) => Ok(Primitive::Dictionary(dict.deep_clone(cloner)?)),
680            Primitive::Integer(i) => Ok(Primitive::Integer(i)),
681            Primitive::Name(ref name) => Ok(Primitive::Name(name.clone())),
682            Primitive::Null => Ok(Primitive::Null),
683            Primitive::Number(n) => Ok(Primitive::Number(n)),
684            Primitive::Reference(r) => Ok(Primitive::Reference(r.deep_clone(cloner)?)),
685            Primitive::Stream(ref s) => Ok(Primitive::Stream(s.deep_clone(cloner)?)),
686            Primitive::String(ref s) => Ok(Primitive::String(s.clone()))
687        }
688    }
689}
690
691impl Trace for Primitive {
692    fn trace(&self, cb: &mut impl FnMut(PlainRef)) {
693        match *self {
694            Primitive::Reference(r) => cb(r),
695            Primitive::Array(ref parts) => parts.iter().for_each(|p| p.trace(cb)),
696            Primitive::Dictionary(ref dict) => dict.values().for_each(|p| p.trace(cb)),
697            _ => ()
698        }
699    }
700}
701
702impl<V: Object> Object for HashMap<Name, V> {
703    fn from_primitive(p: Primitive, resolve: &impl Resolve) -> Result<Self> {
704        match p {
705            Primitive::Null => Ok(HashMap::new()),
706            Primitive::Dictionary (dict) => {
707                let mut new = Self::new();
708                for (key, val) in dict.iter() {
709                    new.insert(key.clone(), V::from_primitive(val.clone(), resolve)?);
710                }
711                Ok(new)
712            }
713            Primitive::Reference (id) => HashMap::from_primitive(resolve.resolve(id)?, resolve),
714            p => Err(PdfError::UnexpectedPrimitive {expected: "Dictionary", found: p.get_debug_name()})
715        }
716    }
717}
718impl<V: ObjectWrite> ObjectWrite for HashMap<Name, V> {
719    fn to_primitive(&self, update: &mut impl Updater) -> Result<Primitive> {
720        if self.is_empty() {
721            Ok(Primitive::Null)
722        } else {
723            let mut dict = Dictionary::new();
724            for (k, v) in self.iter() {
725                dict.insert(k.clone(), v.to_primitive(update)?);
726            }
727            Ok(Primitive::Dictionary(dict))
728        }
729    }
730}
731impl<V: DeepClone> DeepClone for HashMap<Name, V> {
732    fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self> {
733        self.iter().map(|(k, v)| Ok((k.clone(), v.deep_clone(cloner)?))).collect()
734    }
735}
736
737impl<T: Object> Object for Option<T> {
738    fn from_primitive(p: Primitive, resolve: &impl Resolve) -> Result<Self> {
739        match p {
740            Primitive::Null => Ok(None),
741            p => match T::from_primitive(p, resolve) {
742                Ok(p) => Ok(Some(p)),
743                // References to non-existing objects ought not to be an error
744                Err(PdfError::NullRef {..}) => Ok(None),
745                Err(PdfError::FreeObject {..}) => Ok(None),
746                Err(e) if resolve.options().allow_error_in_option => {
747                    warn!("ignoring {:?}", e);
748                    Ok(None)
749                }
750                Err(e) => Err(e)
751            }
752        }
753    }
754}
755impl<T: ObjectWrite> ObjectWrite for Option<T> {
756    fn to_primitive(&self, update: &mut impl Updater) -> Result<Primitive> {
757        match self {
758            None => Ok(Primitive::Null),
759            Some(t) => t.to_primitive(update)
760        }
761    }
762}
763impl<T: DeepClone> DeepClone for Option<T> {
764    fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self> {
765        match self {
766            None => Ok(None),
767            Some(t) => t.deep_clone(cloner).map(Some)
768        }
769    }
770}
771
772impl<T: Trace> Trace for Option<T> {
773    fn trace(&self, cb: &mut impl FnMut(PlainRef)) {
774        if let Some(ref t) = *self {
775            t.trace(cb)
776        }
777    }
778}
779
780impl<T: Object> Object for Box<T> {
781    fn from_primitive(p: Primitive, resolve: &impl Resolve) -> Result<Self> {
782        T::from_primitive(p, resolve).map(Box::new)
783    }
784}
785impl<T: ObjectWrite> ObjectWrite for Box<T> {
786    fn to_primitive(&self, update: &mut impl Updater) -> Result<Primitive> {
787        (**self).to_primitive(update)
788    }
789}
790impl<T: Trace> Trace for Box<T> {
791    fn trace(&self, cb: &mut impl FnMut(PlainRef)) {
792        (**self).trace(cb)
793    }
794}
795
796impl Object for () {
797    fn from_primitive(_p: Primitive, _resolve: &impl Resolve) -> Result<Self> {
798        Ok(())
799    }
800}
801impl ObjectWrite for () {
802    fn to_primitive(&self, _: &mut impl Updater) -> Result<Primitive> {
803        Ok(Primitive::Null)
804    }
805}
806impl Trace for () {}
807
808impl<T, U> Object for (T, U) where T: Object, U: Object {
809    fn from_primitive(p: Primitive, resolve: &impl Resolve) -> Result<Self> {
810        let arr = p.resolve(resolve)?.into_array()?;
811        if arr.len() != 2 {
812            bail!("expected array of length 2 (found {})", arr.len());
813        }
814        let [a, b]: [Primitive; 2] = arr.try_into().unwrap();
815        Ok((T::from_primitive(a, resolve)?, U::from_primitive(b, resolve)?))
816    }
817}
818
819impl<T, U> ObjectWrite for (T, U) where T: ObjectWrite, U: ObjectWrite {
820    fn to_primitive(&self, update: &mut impl Updater) -> Result<Primitive> {
821        Ok(Primitive::Array(vec![self.0.to_primitive(update)?, self.1.to_primitive(update)?]))
822    }
823}
824
825impl<T: Trace, U: Trace> Trace for (T, U) {
826    fn trace(&self, cb: &mut impl FnMut(PlainRef)) {
827        self.0.trace(cb);
828        self.1.trace(cb);
829    }
830}
831
832impl<T: DeepClone> DeepClone for Box<T> {
833    fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self> {
834        Ok(Box::new((&**self).deep_clone(cloner)?))
835    }
836}
837macro_rules! deep_clone_simple {
838    ($($t:ty),*) => (
839        $(
840            impl DeepClone for $t {
841                fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self> {
842                    Ok(self.clone())
843                }
844            }
845        )*
846    )
847}
848deep_clone_simple!(f32, i32, u32, bool, Name, (), Date, PdfString, Rectangle, u8, Arc<[u8]>, Vec<u16>);
849
850impl<A: DeepClone, B: DeepClone> DeepClone for (A, B) {
851    fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self> {
852        Ok((self.0.deep_clone(cloner)?, self.1.deep_clone(cloner)?))
853    }
854}
pdf/object/mod.rs

pdf/object/
mod.rs
