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 QuerySRDF 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>

impl SRDF for RdfData

fn predicates_for_subject( &self, _subject: &Self::Subject, ) -> Result<HashSet<Self::IRI>, Self::Err>

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

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

fn triples_with_predicate( &self, pred: &Self::IRI, ) -> Result<Vec<Triple<Self>>, Self::Err>

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

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

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.

fn neighs( &self, node: &Self::Term, ) -> Result<ListOfIriAndTerms<Self::IRI, Self::Term>, Self::Err>

Get the neighbours of a term This code creates an intermediate vector and is not very efficient TODO: return an iterator

impl SRDFBasic for RdfData

type IRI = NamedNode

RDF predicates

type BNode = BlankNode

Blannk nodes

type Literal = Literal

RDF Literals

type Subject = Subject

RDF subjects

type Term = Term

RDF terms

type Err = RdfDataError

RDF errors

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

fn subject_as_iri(subject: &Self::Subject) -> Option<Self::IRI>

Returns the RDF subject as an IRI if it is an IRI, None if it isn’t

fn subject_as_bnode(subject: &Self::Subject) -> Option<Self::BNode>

Returns the RDF subject as a Blank Node if it is a blank node, None if it isn’t

fn subject_is_iri(subject: &Self::Subject) -> bool

Returns true if the subject is an IRI

fn subject_is_bnode(subject: &Self::Subject) -> bool

Returns true if the subject is a Blank Node

fn term_as_iri(object: &Self::Term) -> Option<&Self::IRI>

fn term_as_bnode(object: &Self::Term) -> Option<Self::BNode>

fn term_as_literal(object: &Self::Term) -> Option<Self::Literal>

fn term_as_object(term: &Self::Term) -> Object

fn object_as_term(obj: &Object) -> Self::Term

fn term_is_iri(object: &Self::Term) -> bool

fn term_is_bnode(object: &Self::Term) -> bool

fn term_is_literal(object: &Self::Term) -> bool

fn term_as_subject(object: &Self::Term) -> Option<Self::Subject>

fn subject_as_term(subject: &Self::Subject) -> Self::Term

fn lexical_form(literal: &Self::Literal) -> &str

fn lang(literal: &Self::Literal) -> Option<String>

fn datatype(literal: &Self::Literal) -> Self::IRI

fn iri_s2iri(iri_s: &IriS) -> Self::IRI

fn term_s2term(term: &Term) -> Self::Term

fn bnode_id2bnode(id: &str) -> Self::BNode

fn iri_as_term(iri: Self::IRI) -> Self::Term

fn iri_as_subject(iri: Self::IRI) -> Self::Subject

fn bnode_as_term(bnode: Self::BNode) -> Self::Term

fn bnode_as_subject(bnode: Self::BNode) -> Self::Subject

fn iri2iri_s(iri: &Self::IRI) -> IriS

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

fn term_as_boolean(object: &Self::Term) -> Option<bool>

fn object_as_subject(obj: &Object) -> Option<Self::Subject>

fn literal_as_boolean(literal: &Self::Literal) -> Option<bool>

fn literal_as_integer(literal: &Self::Literal) -> Option<isize>

fn literal_as_string(literal: &Self::Literal) -> Option<String>

fn term_as_iri_s(term: &Self::Term) -> Option<IriS>

fn term_as_integer(term: &Self::Term) -> Option<isize>

fn term_as_string(term: &Self::Term) -> Option<String>

fn subject_as_object(subject: &Self::Subject) -> Object

fn datatype_str(literal: &Self::Literal) -> String

fn iri_s2subject(iri_s: &IriS) -> Self::Subject

fn iri_s2term(iri_s: &IriS) -> Self::Term

fn bnode_id2term(id: &str) -> Self::Term

fn bnode_id2subject(id: &str) -> Self::Subject

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( &mut self, _subj: &Self::Subject, _pred: &Self::IRI, _obj: &Self::Term, ) -> Result<(), Self::Err>

Adds an RDF triple to the current RDF graph

fn remove_triple( &mut self, _subj: &Self::Subject, _pred: &Self::IRI, _obj: &Self::Term, ) -> Result<(), Self::Err>

Removes an RDf triple to the current RDF graph

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

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