Enum Destination 

pub enum Destination {
    Document {
        path: PathBuf,
        exists: bool,
    },
    SameDocument,
    External(String),
    Foreign {
        workspace: String,
        id: String,
    },
    UnresolvedId(String),
    AmbiguousAlias(String),
    Unresolvable {
        target: String,
        why: String,
    },
}

Where a link lands.

prov’s own Target is the resolution; this adds the two things a frontend about to open a file needs and Target deliberately does not carry — an absolute path rather than a workspace-relative one, and whether the file is there.

Variants

Document

A document in this workspace, at an absolute path.

exists is false for a broken link. It is still a Document and not an error case: the target is well-formed and names a place in this workspace, and an editor’s right answer to a broken link is usually to say so and offer to create it, not to refuse to describe it.

Fields

path: PathBuf

Absolute, ready to open.

exists: bool

Whether a file is actually there.

SameDocument

A #locator alone — a place inside the document the link is written in. prov does not read a document’s internal address space, so where that place is, is the frontend’s question to answer.

External(String)

A URL or mail address. Off-workspace by construction: prov recognizes it by syntax and never resolves it.

Foreign

id:<workspace>/<id> — a document named in another workspace. prov holds no map from a workspace name to a location (that map is a property of the device, not of the archive), so this is as far as resolution goes.

Fields

workspace: String

The workspace qualifier, as written.

id: String

The id within it, as written — never check-verified, since that workspace owns its id space.

UnresolvedId(String)

An id: target with no live registry entry: unknown, tombstoned, or a workspace with no registry at all.

AmbiguousAlias(String)

A nominal ([[My File]]) target several documents claim, so it names no one of them.

Unresolvable

The target is well-formed but cannot be resolved from here, with the reason — a /-absolute path asked about outside any workspace, say.

Fields

target: String

The target as written.

why: String

Why, in a sentence a status line can show.

Implementations

impl Destination

pub fn openable(&self) -> Option<&Path>

The file to open, when there is one that exists.

pub fn describe(&self) -> String

A one-line description, for a status line that has to say what happened when nothing opened.

Examples found in repository

examples/inspect.rs (line 50)

fn main() {
    let path = std::path::PathBuf::from(std::env::args().nth(1).expect("a document"));
    let view = WorkspaceView::discover(&path).expect("discovery");
    match &view {
        Some(v) => println!("workspace: {}", v.root_dir().display()),
        None => println!("workspace: none"),
    }
    let facets = view
        .as_ref()
        .map(|v| v.facets().clone())
        .unwrap_or_default();
    let schema = view.as_ref().map(|v| v.schema_for(&path));
    let session =
        DocumentSession::open_managed(&path, schema, facets.managed_key_names()).expect("open");

    println!("\nkeys:");
    for (key, facet) in facets.classify(session.meta()) {
        let flags = [
            facet.structural().then_some("structural"),
            facet.managed().then_some("managed"),
        ]
        .into_iter()
        .flatten()
        .collect::<Vec<_>>()
        .join(",");
        println!("  {key:<14} {:<9} {flags}", facet.kind());
    }

    println!("\nlinks:");
    for link in links_in(session.meta(), &facets) {
        let landing = match &view {
            Some(v) => v.resolve(&path, &link),
            None => resolve_without_workspace(&path, &link),
        };
        let mark = if matches!(landing, Destination::Document { exists: true, .. }) {
            "→"
        } else {
            "·"
        };
        println!(
            "  {mark} {:<10} {:<22} {}",
            link.relation.name,
            link.display(),
            landing.describe()
        );
    }
}

Trait Implementations

impl Clone for Destination

fn clone(&self) -> Destination

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Destination

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

Formats the value using the given formatter.

impl Eq for Destination

impl PartialEq for Destination

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Destination