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

pdf/object/
mod.rs
