Struct RdfData

pub struct RdfData { /* private fields */ }

Generic abstraction that represents RDF Data which can be behind SPARQL endpoints or an in-memory graph or both The triples in RdfData are taken as the union of the triples of the endpoints and the in-memory graph

Implementations

impl RdfData

pub fn new() -> RdfData

pub fn check_store(&mut self) -> Result<(), RdfDataError>

Checks if the Store has been initialized

By default, the RDF Data Store is not initialized as it is expensive and is only required for SPARQL queries

pub fn from_graph(graph: SRDFGraph) -> Result<RdfData, RdfDataError>

Creates an RdfData from an in-memory RDF Graph

pub fn clean_all(&mut self)

pub fn graph(&self) -> Option<&SRDFGraph>

Get the in-memory graph

pub fn clean_graph(&mut self)

Cleans the in-memory graph

pub fn merge_from_reader<R: Read>( &mut self, read: R, format: &RDFFormat, base: Option<&str>, reader_mode: &ReaderMode, ) -> Result<(), RdfDataError>

Merge the in-memory graph with the graph read from a reader

pub fn from_endpoint(endpoint: SRDFSparql) -> RdfData

Creates an RdfData from an endpoint

pub fn add_endpoint(&mut self, endpoint: SRDFSparql)

Adds a new endpoint to the list of endpoints

pub fn prefixmap_in_memory(&self) -> PrefixMap

Gets the PrefixMap from the in-memory graph

pub fn show_blanknode(&self, bn: &OxBlankNode) -> String

pub fn show_literal(&self, lit: &OxLiteral) -> String

pub fn serialize<W: Write>( &self, format: &RDFFormat, writer: &mut W, ) -> Result<(), RdfDataError>

Trait Implementations

impl Clone for RdfData

fn clone(&self) -> RdfData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RdfData

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

Formats the value using the given formatter.

impl Default for RdfData

fn default() -> Self

Returns the “default value” for a type.

impl FocusRDF for RdfData

fn set_focus(&mut self, focus: &Self::Term)

Set the value of the focus node

fn get_focus(&self) -> &Option<Self::Term>

Get the focus node if it exists

fn get_focus_as_term(&self) -> Result<&Self::Term, RDFParseError>

Get the current focus as a Term

fn get_focus_as_subject(&self) -> Result<Self::Subject, RDFParseError>

Get the current focus as a Subject

impl Query for RdfData

fn triples(&self) -> Result<impl Iterator<Item = Self::Triple>, Self::Err>

fn triples_matching<S, P, O>( &self, subject: S, predicate: P, object: O, ) -> Result<impl Iterator<Item = Self::Triple>, Self::Err>

where S: Matcher<Self::Subject>, P: Matcher<Self::IRI>, O: Matcher<Self::Term>,

Note to implementors: this function needs to retrieve all the triples of the graph. Therefore, for use-cases where the graph is large, this function should be implemented in a way that it does not retrieve all triples at once. As an example, for implementations of SPARQL, this function should be implemented to retrieve just the triples that match the given subject, predicate and object.

fn triples_with_subject<S>( &self, subject: S, ) -> Result<impl Iterator<Item = Self::Triple>, Self::Err>

where S: Matcher<Self::Subject>,

fn triples_with_predicate<P>( &self, predicate: P, ) -> Result<impl Iterator<Item = Self::Triple>, Self::Err>

where P: Matcher<Self::IRI>,

fn triples_with_object<O>( &self, object: O, ) -> Result<impl Iterator<Item = Self::Triple>, Self::Err>

where O: Matcher<Self::Term>,

fn incoming_arcs( &self, object: Self::Term, ) -> Result<HashMap<Self::IRI, HashSet<Self::Subject>>, Self::Err>

fn outgoing_arcs( &self, subject: Self::Subject, ) -> Result<HashMap<Self::IRI, HashSet<Self::Term>>, Self::Err>

get all outgoing arcs from a subject

fn outgoing_arcs_from_list( &self, subject: &Self::Subject, preds: &[Self::IRI], ) -> Result<(HashMap<Self::IRI, HashSet<Self::Term>>, Vec<Self::IRI>), Self::Err>

get outgoing arcs from a node taking into account only a controlled list of preds It returns a HashMap with the outgoing arcs and their values and a list of the predicates that have values and are not in the controlled list.

impl Rdf for RdfData

type IRI = NamedNode

type BNode = BlankNode

type Literal = Literal

type Subject = Subject

type Term = Term

type Triple = Triple

type Err = RdfDataError

fn prefixmap(&self) -> Option<PrefixMap>

fn qualify_iri(&self, node: &Self::IRI) -> String

fn qualify_subject(&self, subj: &Self::Subject) -> String

fn qualify_term(&self, term: &Self::Term) -> String

fn resolve_prefix_local( &self, prefix: &str, local: &str, ) -> Result<IriS, PrefixMapError>

Resolves a a prefix and a local name and obtains the corresponding full IriS

impl SRDFBuilder for RdfData

fn empty() -> Self

Returns an empty RDF graph

fn add_base(&mut self, _base: &Option<IriS>) -> Result<(), Self::Err>

Adds an optional IRI as base

fn add_prefix(&mut self, _alias: &str, _iri: &IriS) -> Result<(), Self::Err>

Adds a prefix declaration to the current RDF graph

fn add_prefix_map(&mut self, _prefix_map: PrefixMap) -> Result<(), Self::Err>

Adds a prefix map declaration to the current RDF graph

fn add_triple<S, P, O>( &mut self, _subj: S, _pred: P, _obj: O, ) -> Result<(), Self::Err>

where S: Into<Self::Subject>, P: Into<Self::IRI>, O: Into<Self::Term>,

Adds an RDF triple to the current RDF graph

fn remove_triple<S, P, O>( &mut self, _subj: S, _pred: P, _obj: O, ) -> Result<(), Self::Err>

where S: Into<Self::Subject>, P: Into<Self::IRI>, O: Into<Self::Term>,

Removes an RDF triple to the current RDF graph

fn add_type<S, T>(&mut self, _node: S, _type_: T) -> Result<(), Self::Err>

where S: Into<Self::Subject>, T: Into<Self::Term>,

Adds an rdf:type declaration to the current RDF graph

fn serialize<W: Write>( &self, format: &RDFFormat, writer: &mut W, ) -> Result<(), Self::Err>

Serialize the current graph to a Write implementation

fn add_bnode(&mut self) -> Result<Self::BNode, Self::Err>

Adds an Blank node to the RDF graph and get the node identifier

impl Sparql for RdfData

fn query_select( &self, query_str: &str, ) -> Result<QuerySolutions<RdfData>, RdfDataError>

where Self: Sized,

fn query_ask(&self, _query: &str) -> Result<bool, Self::Err>