Struct NameTree 

pub struct NameTree {
    pub root: Dict,
}

A name tree rooted at one category of the catalog’s /Names.

Fields

root: Dict

The tree’s root node.

Implementations

impl NameTree

pub fn open<R: Resolve>( catalog: &Dict, category: &Name, r: &R, ) -> Option<NameTree>

Opens catalog[/Names][<category>].

A missing link at either step means no tree, which is not the same as an empty one: a lookup against nothing and a lookup against an empty tree take different fallback paths at the caller.

use pdfrum_common::{Diagnostics, Limits};
use pdfrum_doc::NameTree;
use pdfrum_object::{Array, Dict, Name, NoResolve, Object, PdfString, names};

let dests = Dict::from_pairs([(
    Name::from("Names"),
    Object::Array(Array::of([
        Object::Str(PdfString::literal(b"intro")),
        Object::Array(Array::of([Object::Int(0), Object::Name(Name::from("Fit"))])),
    ])),
)]);
let catalog = Dict::from_pairs([(
    Name::from("Names"),
    Object::Dict(Dict::from_pairs([(Name::from("Dests"), Object::Dict(dests))])),
)]);

let tree = NameTree::open(&catalog, &Name::from("Dests"), &NoResolve)
    .expect("the catalog carries a `/Names /Dests` tree");
let (limits, mut diags) = (Limits::default(), Diagnostics::default());

// A missing link at either step is *no tree*, not an empty one.
assert!(NameTree::open(&Dict::default(), &Name::from("Dests"), &NoResolve).is_none());

pub fn lookup<R: Resolve>( &self, key: &str, r: &R, limits: &Limits, diags: &mut Diagnostics, ) -> Option<Object>

Looks up one key’s value.

use pdfrum_common::{Diagnostics, Limits};
use pdfrum_doc::NameTree;
use pdfrum_object::{Array, Dict, Name, NoResolve, Object, PdfString, names};

let dests = Dict::from_pairs([(
    Name::from("Names"),
    Object::Array(Array::of([
        Object::Str(PdfString::literal(b"intro")),
        Object::Array(Array::of([Object::Int(0), Object::Name(Name::from("Fit"))])),
    ])),
)]);
let catalog = Dict::from_pairs([(
    Name::from("Names"),
    Object::Dict(Dict::from_pairs([(Name::from("Dests"), Object::Dict(dests))])),
)]);

let tree = NameTree::open(&catalog, &Name::from("Dests"), &NoResolve)
    .expect("the catalog carries a `/Names /Dests` tree");
let (limits, mut diags) = (Limits::default(), Diagnostics::default());

assert!(tree.lookup("intro", &NoResolve, &limits, &mut diags).is_some());
assert!(tree.lookup("absent", &NoResolve, &limits, &mut diags).is_none());

pub fn lookup_by_index<R: Resolve>( &self, target: usize, r: &R, limits: &Limits, diags: &mut Diagnostics, ) -> Option<(String, Object)>

Looks up the index-th entry in tree order, returning its key and value.

Two differences from the by-name path: there is no cycle guard at all — a /Kids loop is stopped only by the depth cap — and /Limits is not consulted, because this is a pure in-order walk. A slot whose value will not resolve aborts the whole search rather than being skipped.

use pdfrum_common::{Diagnostics, Limits};
use pdfrum_doc::NameTree;
use pdfrum_object::{Array, Dict, Name, NoResolve, Object, PdfString, names};

let dests = Dict::from_pairs([(
    Name::from("Names"),
    Object::Array(Array::of([
        Object::Str(PdfString::literal(b"intro")),
        Object::Array(Array::of([Object::Int(0), Object::Name(Name::from("Fit"))])),
    ])),
)]);
let catalog = Dict::from_pairs([(
    Name::from("Names"),
    Object::Dict(Dict::from_pairs([(Name::from("Dests"), Object::Dict(dests))])),
)]);

let tree = NameTree::open(&catalog, &Name::from("Dests"), &NoResolve)
    .expect("the catalog carries a `/Names /Dests` tree");
let (limits, mut diags) = (Limits::default(), Diagnostics::default());

let (key, _value) = tree
    .lookup_by_index(0, &NoResolve, &limits, &mut diags)
    .expect("the tree has a first entry");
assert_eq!(key, "intro");

pub fn count<R: Resolve>( &self, r: &R, limits: &Limits, diags: &mut Diagnostics, ) -> usize

How many entries the tree holds.

The visited set here is on dictionary identity, so an inline node counts too — a different guard from the by-name lookup’s.

use pdfrum_common::{Diagnostics, Limits};
use pdfrum_doc::NameTree;
use pdfrum_object::{Array, Dict, Name, NoResolve, Object, PdfString, names};

let dests = Dict::from_pairs([(
    Name::from("Names"),
    Object::Array(Array::of([
        Object::Str(PdfString::literal(b"intro")),
        Object::Array(Array::of([Object::Int(0), Object::Name(Name::from("Fit"))])),
    ])),
)]);
let catalog = Dict::from_pairs([(
    Name::from("Names"),
    Object::Dict(Dict::from_pairs([(Name::from("Dests"), Object::Dict(dests))])),
)]);

let tree = NameTree::open(&catalog, &Name::from("Dests"), &NoResolve)
    .expect("the catalog carries a `/Names /Dests` tree");
let (limits, mut diags) = (Limits::default(), Diagnostics::default());

assert_eq!(tree.count(&NoResolve, &limits, &mut diags), 1);

Trait Implementations

impl Clone for NameTree

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NameTree

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for NameTree

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for NameTree