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>( &mut self, read: R, format: &RDFFormat, base: Option<&str>, reader_mode: &ReaderMode, ) -> Result<(), RdfDataError>

where R: Read,

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: &BlankNode) -> String

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

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

where W: Write,

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<(), Error>

Formats the value using the given formatter.

impl Default for RdfData

fn default() -> RdfData

Returns the “default value” for a type.

impl FocusRDF for RdfData

fn set_focus(&mut self, focus: &<RdfData as SRDFBasic>::Term)

Set the value of the focus node

fn get_focus(&self) -> &Option<<RdfData as SRDFBasic>::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 RdfData: Sized,

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

impl SRDF for RdfData

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

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

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

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

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

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

fn outgoing_arcs_from_list( &self, subject: &<RdfData as SRDFBasic>::Subject, preds: &[<RdfData as SRDFBasic>::IRI], ) -> Result<(HashMap<<RdfData as SRDFBasic>::IRI, HashSet<<RdfData as SRDFBasic>::Term>>, Vec<<RdfData as SRDFBasic>::IRI>), <RdfData as SRDFBasic>::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: &<RdfData as SRDFBasic>::Term, ) -> Result<Vec<(<RdfData as SRDFBasic>::IRI, HashSet<<RdfData as SRDFBasic>::Term>)>, <RdfData as SRDFBasic>::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: &<RdfData as SRDFBasic>::Subject, ) -> Option<<RdfData as SRDFBasic>::IRI>

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

fn subject_as_bnode( subject: &<RdfData as SRDFBasic>::Subject, ) -> Option<<RdfData as SRDFBasic>::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: &<RdfData as SRDFBasic>::Subject) -> bool

Returns true if the subject is an IRI

fn subject_is_bnode(subject: &<RdfData as SRDFBasic>::Subject) -> bool

Returns true if the subject is a Blank Node

fn term_as_iri( object: &<RdfData as SRDFBasic>::Term, ) -> Option<&<RdfData as SRDFBasic>::IRI>

fn term_as_bnode( object: &<RdfData as SRDFBasic>::Term, ) -> Option<<RdfData as SRDFBasic>::BNode>

fn term_as_literal( object: &<RdfData as SRDFBasic>::Term, ) -> Option<<RdfData as SRDFBasic>::Literal>

fn term_as_object(term: &<RdfData as SRDFBasic>::Term) -> Object

fn object_as_term(obj: &Object) -> <RdfData as SRDFBasic>::Term

fn term_is_iri(object: &<RdfData as SRDFBasic>::Term) -> bool

fn term_is_bnode(object: &<RdfData as SRDFBasic>::Term) -> bool

fn term_is_literal(object: &<RdfData as SRDFBasic>::Term) -> bool

fn term_as_subject( object: &<RdfData as SRDFBasic>::Term, ) -> Option<<RdfData as SRDFBasic>::Subject>

fn subject_as_term( subject: &<RdfData as SRDFBasic>::Subject, ) -> <RdfData as SRDFBasic>::Term

fn lexical_form(literal: &<RdfData as SRDFBasic>::Literal) -> &str

fn lang(literal: &<RdfData as SRDFBasic>::Literal) -> Option<String>

fn datatype( literal: &<RdfData as SRDFBasic>::Literal, ) -> <RdfData as SRDFBasic>::IRI

fn iri_s2iri(iri_s: &IriS) -> <RdfData as SRDFBasic>::IRI

fn term_s2term(term: &Term) -> <RdfData as SRDFBasic>::Term

fn bnode_id2bnode(id: &str) -> <RdfData as SRDFBasic>::BNode

fn iri_as_term(iri: <RdfData as SRDFBasic>::IRI) -> <RdfData as SRDFBasic>::Term

fn iri_as_subject( iri: <RdfData as SRDFBasic>::IRI, ) -> <RdfData as SRDFBasic>::Subject

fn bnode_as_term( bnode: <RdfData as SRDFBasic>::BNode, ) -> <RdfData as SRDFBasic>::Term

fn bnode_as_subject( bnode: <RdfData as SRDFBasic>::BNode, ) -> <RdfData as SRDFBasic>::Subject

fn iri2iri_s(iri: &<RdfData as SRDFBasic>::IRI) -> IriS

fn qualify_iri(&self, node: &<RdfData as SRDFBasic>::IRI) -> String

fn qualify_subject(&self, subj: &<RdfData as SRDFBasic>::Subject) -> String

fn qualify_term(&self, term: &<RdfData as SRDFBasic>::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() -> RdfData

Returns an empty RDF graph

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

Adds an optional IRI as base

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

Adds a prefix declaration to the current RDF graph

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

Adds a prefix map declaration to the current RDF graph

fn add_triple( &mut self, _subj: &<RdfData as SRDFBasic>::Subject, _pred: &<RdfData as SRDFBasic>::IRI, _obj: &<RdfData as SRDFBasic>::Term, ) -> Result<(), <RdfData as SRDFBasic>::Err>

Adds an RDF triple to the current RDF graph

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

Removes an RDf triple to the current RDF graph

fn add_type( &mut self, _node: &Object, _type_: <RdfData as SRDFBasic>::Term, ) -> Result<(), <RdfData as SRDFBasic>::Err>

Adds an rdf:type declaration to the current RDF graph

fn serialize<W>( &self, format: &RDFFormat, writer: &mut W, ) -> Result<(), <RdfData as SRDFBasic>::Err>

where W: Write,

Serialize the current graph to a Write implementation