rudof_lib 0.3.27

RDF and Knowledge Graphs processing tool
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

use crate::{
    Result, Rudof,
    errors::DataError,
    formats::{IriNormalizationMode, NodeInspectionMode},
    types::{Data, NodeNeighborhood},
    utils::{convert_predicate_strings_to_iris, parse_node_selector, session_base_iri},
};
use prefixmap::DerefIri;
use rudof_rdf::rdf_core::Rdf;
use sparql_service::RdfData;

/// Returns a lazy iterator over the neighborhood of every node matched by `node`
pub fn node_neighborhood<'a>(
    rudof: &'a Rudof,
    node: &str,
    predicates: Option<&[String]>,
    mode: Option<&NodeInspectionMode>,
    depth: Option<usize>,
    iri_mode: IriNormalizationMode,
) -> Result<NodeNeighborhood<'a>> {
    let Some(Data::RDFData(rdf)) = rudof.data.as_ref() else {
        return Err(Box::new(DataError::NoRdfDataLoaded).into());
    };
    let rdf: &'a RdfData = rdf;

    let base = session_base_iri(rudof)?;

    let node_selector = parse_node_selector(node, iri_mode)?
        .deref_iri(base.as_ref(), Some(&rdf.prefixmap().unwrap_or_default()))
        .map_err(|e| {
            Box::new(DataError::FailedTermResolution {
                term: node.trim().to_string(),
                error: e.to_string(),
            })
        })?;
    let roots = node_selector
        .nodes(rdf)
        .map_err(|e| Box::new(DataError::FailedArcRetrieval { error: e.to_string() }))?;

    let predicates = convert_predicate_strings_to_iris(predicates.unwrap_or_default(), base.as_ref(), rdf)?;
    let directions = mode.copied().unwrap_or_default().directions();

    Ok(NodeNeighborhood::new(
        rdf,
        roots,
        predicates,
        directions,
        depth.unwrap_or(1),
    ))
}