Trait GraphView

pub trait GraphView: Sized + Send {
    type Stream: Send + Unpin + Stream<Item = Arc<Triple>>;
    type Filter<T: TripleFilter + Send + Sync + Unpin>: GraphView;
    type Matches<'g>: GraphView;
    type Describe<'g>: GraphView;
    type SubjectStream<'g>: Send + Unpin + Stream<Item = Arc<Term>>;
    type PredicateStream<'g>: Send + Unpin + Stream<Item = Arc<Term>>;
    type ObjectStream<'g>: Send + Unpin + Stream<Item = Arc<Term>>;

    // Required methods
    fn stream(
        self,
    ) -> impl Future<Output = Result<Self::Stream, GraphError>> + Send;
    fn filter<F>(
        self,
        filter: F,
    ) -> impl Future<Output = Result<Self::Filter<F>, GraphError>> + Send
       where F: TripleFilter + Send + Sync + Unpin;
    fn matches<'g>(
        self,
        subject: Option<&'g Term>,
        predicate: Option<&'g Term>,
        object: Option<&'g Term>,
        limit: Option<usize>,
    ) -> impl Future<Output = Result<Self::Matches<'g>, GraphError>> + Send;
    fn describe(
        self,
        subject: Option<&Term>,
        limit: Option<usize>,
    ) -> impl Future<Output = Result<Self::Describe<'_>, GraphError>> + Send;
    fn subjects<'g>(
        self,
        predicate: Option<&'g Term>,
        object: Option<&'g Term>,
        limit: Option<usize>,
    ) -> impl Future<Output = Result<Self::SubjectStream<'g>, GraphError>> + Send;
    fn predicates<'g>(
        self,
        subject: Option<&'g Term>,
        object: Option<&'g Term>,
        limit: Option<usize>,
    ) -> impl Future<Output = Result<Self::ObjectStream<'g>, GraphError>> + Send;
    fn objects<'g>(
        self,
        subject: Option<&'g Term>,
        predicate: Option<&'g Term>,
        limit: Option<usize>,
    ) -> impl Future<Output = Result<Self::ObjectStream<'g>, GraphError>> + Send;

    // Provided methods
    fn subject(
        self,
        predicate: Option<&Term>,
        object: Option<&Term>,
    ) -> impl Future<Output = Result<Option<Arc<Term>>, GraphError>> + Send { ... }
    fn predicate(
        self,
        subject: Option<&Term>,
        object: Option<&Term>,
    ) -> impl Future<Output = Result<Option<Arc<Term>>, GraphError>> + Send { ... }
    fn object(
        self,
        subject: Option<&Term>,
        predicate: Option<&Term>,
    ) -> impl Future<Output = Result<Option<Arc<Term>>, GraphError>> + Send { ... }
    fn contains(
        self,
        triple: TripleRef<'_>,
    ) -> impl Future<Output = Result<bool, GraphError>> + Send { ... }
    fn default_triple_size_hint() -> usize { ... }
    fn default_buf_size_hint() -> usize { ... }
    fn triple_size_hint(&self) -> usize { ... }
    fn buf_size_hint(&self) -> usize { ... }
}

Required Associated Types

type Stream: Send + Unpin + Stream<Item = Arc<Triple>>

type Filter<T: TripleFilter + Send + Sync + Unpin>: GraphView

type Matches<'g>: GraphView

type Describe<'g>: GraphView

type SubjectStream<'g>: Send + Unpin + Stream<Item = Arc<Term>>

type PredicateStream<'g>: Send + Unpin + Stream<Item = Arc<Term>>

type ObjectStream<'g>: Send + Unpin + Stream<Item = Arc<Term>>

Required Methods

fn stream(self) -> impl Future<Output = Result<Self::Stream, GraphError>> + Send

fn filter<F>( self, filter: F, ) -> impl Future<Output = Result<Self::Filter<F>, GraphError>> + Send

where F: TripleFilter + Send + Sync + Unpin,

fn matches<'g>( self, subject: Option<&'g Term>, predicate: Option<&'g Term>, object: Option<&'g Term>, limit: Option<usize>, ) -> impl Future<Output = Result<Self::Matches<'g>, GraphError>> + Send

fn describe( self, subject: Option<&Term>, limit: Option<usize>, ) -> impl Future<Output = Result<Self::Describe<'_>, GraphError>> + Send

fn subjects<'g>( self, predicate: Option<&'g Term>, object: Option<&'g Term>, limit: Option<usize>, ) -> impl Future<Output = Result<Self::SubjectStream<'g>, GraphError>> + Send

fn predicates<'g>( self, subject: Option<&'g Term>, object: Option<&'g Term>, limit: Option<usize>, ) -> impl Future<Output = Result<Self::ObjectStream<'g>, GraphError>> + Send

fn objects<'g>( self, subject: Option<&'g Term>, predicate: Option<&'g Term>, limit: Option<usize>, ) -> impl Future<Output = Result<Self::ObjectStream<'g>, GraphError>> + Send

Provided Methods

fn subject( self, predicate: Option<&Term>, object: Option<&Term>, ) -> impl Future<Output = Result<Option<Arc<Term>>, GraphError>> + Send

fn predicate( self, subject: Option<&Term>, object: Option<&Term>, ) -> impl Future<Output = Result<Option<Arc<Term>>, GraphError>> + Send

fn object( self, subject: Option<&Term>, predicate: Option<&Term>, ) -> impl Future<Output = Result<Option<Arc<Term>>, GraphError>> + Send

fn contains( self, triple: TripleRef<'_>, ) -> impl Future<Output = Result<bool, GraphError>> + Send

fn default_triple_size_hint() -> usize

fn default_buf_size_hint() -> usize

fn triple_size_hint(&self) -> usize

fn buf_size_hint(&self) -> usize

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a, T> GraphView for &'a GraphORMMeta<T>

where T: GraphORM + Unpin + Debug + PartialEq + Sync + Send + 'a,

type Stream = Pin<Box<dyn Stream<Item = Arc<Triple>> + Send + Unpin + 'a>>

type Filter<FilterType: TripleFilter + Send + Sync + Unpin> = DefaultFilter<&'a GraphORMMeta<T>, FilterType>

type Matches<'matches> = DefaultMatches<'matches, &'a GraphORMMeta<T>>

type Describe<'describe> = DefaultDescribe<'describe, &'a GraphORMMeta<T>>

type SubjectStream<'stream> = Map<<<&'a GraphORMMeta<T> as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type PredicateStream<'stream> = Map<<<&'a GraphORMMeta<T> as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type ObjectStream<'stream> = Map<<<&'a GraphORMMeta<T> as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

async fn stream( self, ) -> Result<<&'a GraphORMMeta<T> as GraphView>::Stream, GraphError>

async fn filter<FilterType>( self, filter: FilterType, ) -> Result<<&'a GraphORMMeta<T> as GraphView>::Filter<FilterType>, GraphError>

where FilterType: TripleFilter + Send + Sync + Unpin,

async fn matches<'matches>( self, subject: Option<&'matches Term>, predicate: Option<&'matches Term>, object: Option<&'matches Term>, limit: Option<usize>, ) -> Result<<&'a GraphORMMeta<T> as GraphView>::Matches<'matches>, GraphError>

async fn describe( self, subject: Option<&Term>, limit: Option<usize>, ) -> Result<<&'a GraphORMMeta<T> as GraphView>::Describe<'_>, GraphError>

async fn subjects<'stream>( self, arg1: Option<&'stream Term>, arg2: Option<&'stream Term>, limit: Option<usize>, ) -> Result<<&'a GraphORMMeta<T> as GraphView>::ObjectStream<'stream>, GraphError>

async fn predicates<'stream>( self, arg1: Option<&'stream Term>, arg2: Option<&'stream Term>, limit: Option<usize>, ) -> Result<<&'a GraphORMMeta<T> as GraphView>::PredicateStream<'stream>, GraphError>

async fn objects<'stream>( self, arg1: Option<&'stream Term>, arg2: Option<&'stream Term>, limit: Option<usize>, ) -> Result<<&'a GraphORMMeta<T> as GraphView>::ObjectStream<'stream>, GraphError>

Implementors

impl<'a, G> GraphView for DefaultDescribe<'a, G>

where G: GraphView,

type Stream = <DefaultMatches<'a, G> as GraphView>::Stream

type Filter<FilterType: TripleFilter + Send + Sync + Unpin> = DefaultFilter<DefaultDescribe<'a, G>, FilterType>

type Matches<'matches> = DefaultMatches<'matches, DefaultDescribe<'a, G>>

type Describe<'describe> = DefaultDescribe<'describe, DefaultDescribe<'a, G>>

type SubjectStream<'stream> = Map<<<DefaultDescribe<'a, G> as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type PredicateStream<'stream> = Map<<<DefaultDescribe<'a, G> as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type ObjectStream<'stream> = Map<<<DefaultDescribe<'a, G> as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

impl<'g> GraphView for &'g ConfigurableGraphs

type Stream = Box<dyn Stream<Item = Arc<Triple>> + Send + Unpin + 'g>

type Filter<FilterType> = DefaultFilter<&'g ConfigurableGraphs, FilterType> where FilterType: TripleFilter + Send + Sync + Unpin

type Matches<'matches> = DefaultMatches<'matches, &'g ConfigurableGraphs>

type Describe<'describe> = DefaultDescribe<'describe, &'g ConfigurableGraphs>

type SubjectStream<'stream> = Map<<<&'g ConfigurableGraphs as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type PredicateStream<'stream> = Map<<<&'g ConfigurableGraphs as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type ObjectStream<'stream> = Map<<<&'g ConfigurableGraphs as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

impl<'g> GraphView for &'g SimpleGraph

type Stream = Iter<Cloned<Iter<'g, Arc<Triple>>>>

type Filter<FilterType> = DefaultFilter<&'g SimpleGraph, FilterType> where FilterType: TripleFilter + Send + Sync + Unpin

type Matches<'matches> = DefaultMatches<'matches, &'g SimpleGraph>

type Describe<'describe> = DefaultDescribe<'describe, &'g SimpleGraph>

type SubjectStream<'stream> = Map<<<&'g SimpleGraph as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type PredicateStream<'stream> = Map<<<&'g SimpleGraph as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type ObjectStream<'stream> = Map<<<&'g SimpleGraph as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

impl<'g> GraphView for &'g LocalFileSourceGraph

type Stream = TripleParser<BufReader<File>>

type Filter<FilterType> = DefaultFilter<&'g LocalFileSourceGraph, FilterType> where FilterType: TripleFilter + Send + Sync + Unpin

type Matches<'matches> = DefaultMatches<'matches, &'g LocalFileSourceGraph>

type Describe<'describe> = DefaultDescribe<'describe, &'g LocalFileSourceGraph>

type SubjectStream<'stream> = Map<<<&'g LocalFileSourceGraph as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type PredicateStream<'stream> = Map<<<&'g LocalFileSourceGraph as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type ObjectStream<'stream> = Map<<<&'g LocalFileSourceGraph as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

impl<'g> GraphView for &'g GraphStoreHttpSourceGraph

type Stream = Box<dyn Stream<Item = Arc<Triple>> + Send + Unpin + 'g>

type Filter<FilterType> = DefaultFilter<&'g GraphStoreHttpSourceGraph, FilterType> where FilterType: TripleFilter + Send + Sync + Unpin

type Matches<'matches> = DefaultMatches<'matches, &'g GraphStoreHttpSourceGraph>

type Describe<'describe> = DefaultDescribe<'describe, &'g GraphStoreHttpSourceGraph>

type SubjectStream<'stream> = Map<<<&'g GraphStoreHttpSourceGraph as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type PredicateStream<'stream> = Map<<<&'g GraphStoreHttpSourceGraph as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type ObjectStream<'stream> = Map<<<&'g GraphStoreHttpSourceGraph as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

impl<'g, G> GraphView for DefaultMatches<'g, G>

where G: GraphView,

type Stream = Map<TakeWhile<Enumerate<<<G as GraphView>::Filter<Box<dyn Fn(TripleRef<'_>) -> bool + Send + Sync + 'g>> as GraphView>::Stream>, Ready<bool>, Box<dyn Fn(&(usize, Arc<Triple>)) -> Ready<bool> + Send>>, fn(_: (usize, Arc<Triple>)) -> Arc<Triple>>

type Filter<FilterType: TripleFilter + Send + Sync + Unpin> = DefaultFilter<DefaultMatches<'g, G>, FilterType>

type Matches<'matches> = DefaultMatches<'matches, DefaultMatches<'g, G>>

type Describe<'describe> = DefaultDescribe<'describe, DefaultMatches<'g, G>>

type SubjectStream<'stream> = Map<<<DefaultMatches<'g, G> as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type PredicateStream<'stream> = Map<<<DefaultMatches<'g, G> as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type ObjectStream<'stream> = Map<<<DefaultMatches<'g, G> as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

impl<G, T> GraphView for DefaultFilter<G, T>

where G: GraphView, T: TripleFilter + Send + Sync + Unpin,

type Stream = DefaultFilterStream<<G as GraphView>::Stream, T>

type Filter<FilterType: TripleFilter + Send + Sync + Unpin> = DefaultFilter<DefaultFilter<G, T>, FilterType>

type Matches<'matches> = DefaultMatches<'matches, DefaultFilter<G, T>>

type Describe<'describe> = DefaultDescribe<'describe, DefaultFilter<G, T>>

type SubjectStream<'stream> = Map<<<DefaultFilter<G, T> as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type PredicateStream<'stream> = Map<<<DefaultFilter<G, T> as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>

type ObjectStream<'stream> = Map<<<DefaultFilter<G, T> as GraphView>::Matches<'stream> as GraphView>::Stream, fn(_: Arc<Triple>) -> Arc<Term>>