Skip to main content

Single

graphrecords_query::element

Struct Single 

Source 
pub struct Single;

Trait Implementations§

Source§

impl<A: Alignment, V: BareValueDomain> AlignableArity<Bare<V>, A> for Single

Source§

type Retention = Preserving

Source§

fn lookup<'a, 'prepared>( prepared: &'prepared Self::Prepared<'a>, _address: &A::Address<'a>, ) -> Lookup<'prepared, QueryResult<V::Value<'a>>>
where Bare<V>: 'a,

Source§

impl Arity for Single

Source§

type AfterDrop = Single

Source§

type AfterOrderedExpansion = Multiple<Ordered>

Source§

type AfterUnorderedExpansion = Multiple<Unordered>

Source§

type Container<'a, X: 'a> = Option<X>

Source§

fn map_elements<'a, X: 'a, Y: 'a>( container: Self::Container<'a, X>, function: impl Fn(X) -> Y + 'a, ) -> Self::Container<'a, Y>

Source§

fn filter_map_elements<'a, X: 'a, Y: 'a>( container: Self::Container<'a, X>, function: impl Fn(X) -> Option<Y> + 'a, ) -> <Self::AfterDrop as Arity>::Container<'a, Y>

Source§

fn flat_map_ordered_elements<'a, X: 'a, Y: 'a>( container: Self::Container<'a, X>, function: impl Fn(X) -> Vec<Y> + 'a, ) -> <Self::AfterOrderedExpansion as Arity>::Container<'a, Y>

Source§

fn flat_map_unordered_elements<'a, X: 'a, Y: 'a>( container: Self::Container<'a, X>, function: impl Fn(X) -> Vec<Y> + 'a, ) -> <Self::AfterUnorderedExpansion as Arity>::Container<'a, Y>

Source§

impl<V: BareValueDomain> BucketFailureArity<Bare<V>> for Single

Source§

fn bucket_failure<'payload, 'a>( payload: &'payload QueryResult<Self::Container<'a, <Bare<V> as ElementShape>::Element<'a>>>, ) -> Option<&'payload Failure>
where Bare<V>: 'a,

Source§

impl<I: IndexDomain, V: ValueDomain> BucketFailureArity<Indexed<I, V>> for Single

Source§

fn bucket_failure<'payload, 'a>( payload: &'payload QueryResult<Self::Container<'a, <Indexed<I, V> as ElementShape>::Element<'a>>>, ) -> Option<&'payload Failure>
where Indexed<I, V>: 'a,

Source§

impl<S: CacheableShape> CacheableArity<S> for Single

Source§

type Cached = Option<<S as CacheableShape>::CachedElement>

Source§

fn into_cached<'a>(values: Self::Container<'a, S::Element<'a>>) -> Self::Cached

Source§

fn from_cached(cached: &Self::Cached) -> Self::Container<'_, S::Element<'_>>

Source§

impl<I: IndexDomain, V: ValueDomain> EnumerableArity<Indexed<I, V>, I> for Single

Source§

fn elements<'a>( prepared: Self::Prepared<'a>, ) -> Self::Container<'a, (I::Index<'a>, QueryResult<V::Value<'a>>)>
where Indexed<I, V>: 'a,

Source§

impl<E: EntityDomain> LaneKernel<Bare<EntityReference<E>>, Single> for SelectOperation

Source§

type Output = OperandHandle<Indexed<E, Unit>, Single>

Source§

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, EntityReference<E>, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<V: BareValueDomain> LaneKernel<Bare<V>, Single> for CountOperation

Source§

type Output = OperandHandle<Bare<Scalar>, Definite>

Source§

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<V: BareValueDomain> LaneKernel<Bare<V>, Single> for Raise

Source§

type Output = OperandHandle<Bare<V>, Single>

Source§

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<V, C> LaneKernel<Bare<V>, Single> for RaiseWhen<C>
where V: BareValueDomain, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

Source§

type Output = OperandHandle<Bare<V>, Single>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<V: BareValueDomain, D: Diagnostic> LaneKernel<Bare<V>, Single> for RaiseErrorsOf<D>

Source§

type Output = OperandHandle<Bare<V>, Single>

Source§

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<V: BareValueDomain, G: ErrorGroup> LaneKernel<Bare<V>, Single> for RaiseErrorsIn<G>

Source§

type Output = OperandHandle<Bare<V>, Single>

Source§

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<V: BareValueDomain, E: Error + 'static> LaneKernel<Bare<V>, Single> for RaiseErrorsWithCause<E>

Source§

type Output = OperandHandle<Bare<V>, Single>

Source§

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<V, D, C> LaneKernel<Bare<V>, Single> for RaiseWhenErrorsOf<D, C>
where V: BareValueDomain, D: Diagnostic, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

Source§

type Output = OperandHandle<Bare<V>, Single>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<V, G, C> LaneKernel<Bare<V>, Single> for RaiseWhenErrorsIn<G, C>
where V: BareValueDomain, G: ErrorGroup, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

Source§

type Output = OperandHandle<Bare<V>, Single>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<V, E, C> LaneKernel<Bare<V>, Single> for RaiseWhenErrorsWithCause<E, C>
where V: BareValueDomain, E: Error + 'static, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

Source§

type Output = OperandHandle<Bare<V>, Single>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl LaneKernel<Indexed<GraphRecordAttribute, Unit>, Single> for EdgesOperation

Source§

type Output = OperandHandle<Indexed<u32, Unit>, Multiple<Unordered>>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, NodeIndex, Unit, Single>, direction: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

Source§

impl LaneKernel<Indexed<GraphRecordAttribute, Unit>, Single> for NeighborsOperation

Source§

type Output = OperandHandle<Indexed<GraphRecordAttribute, Unit>, Multiple<Unordered>>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, NodeIndex, Unit, Single>, direction: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

Source§

impl<E: EntityDomain, I: IndexDomain> LaneKernel<Indexed<I, EntityReference<E>>, Single> for SelectOperation

Source§

type Output = OperandHandle<Indexed<E, Unit>, Single>

Source§

fn execute<'a>( _graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, EntityReference<E>, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<I: IndexDomain> LaneKernel<Indexed<I, EntityReference<GraphRecordAttribute>>, Single> for EdgesOperation

Source§

type Output = OperandHandle<Indexed<u32, Unit>, Multiple<Unordered>>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, EntityReference<NodeIndex>, Single>, direction: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

Source§

impl<I: IndexDomain> LaneKernel<Indexed<I, EntityReference<GraphRecordAttribute>>, Single> for NeighborsOperation

Source§

type Output = OperandHandle<Indexed<GraphRecordAttribute, Unit>, Multiple<Unordered>>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, EntityReference<NodeIndex>, Single>, direction: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

Source§

impl<I: IndexDomain> LaneKernel<Indexed<I, EntityReference<u32>>, Single> for NodesOperation

Source§

type Output = OperandHandle<Indexed<GraphRecordAttribute, Unit>, Multiple<Unordered>>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, EntityReference<EdgeIndex>, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

Source§

impl<I: IndexDomain, V: ValueDomain> LaneKernel<Indexed<I, V>, Single> for CountOperation

Source§

type Output = OperandHandle<Bare<Scalar>, Definite>

Source§

fn execute<'a>( _graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<I: IndexDomain, V: ValueDomain> LaneKernel<Indexed<I, V>, Single> for Raise

Source§

type Output = OperandHandle<Indexed<I, V>, Single>

Source§

fn execute<'a>( _graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<I, V, C> LaneKernel<Indexed<I, V>, Single> for RaiseWhen<C>
where I: IndexDomain, V: ValueDomain, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

Source§

type Output = OperandHandle<Indexed<I, V>, Single>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, V, Single>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<I: IndexDomain, V: ValueDomain, D: Diagnostic> LaneKernel<Indexed<I, V>, Single> for RaiseErrorsOf<D>

Source§

type Output = OperandHandle<Indexed<I, V>, Single>

Source§

fn execute<'a>( _graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<I: IndexDomain, V: ValueDomain, G: ErrorGroup> LaneKernel<Indexed<I, V>, Single> for RaiseErrorsIn<G>

Source§

type Output = OperandHandle<Indexed<I, V>, Single>

Source§

fn execute<'a>( _graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<I: IndexDomain, V: ValueDomain, E: Error + 'static> LaneKernel<Indexed<I, V>, Single> for RaiseErrorsWithCause<E>

Source§

type Output = OperandHandle<Indexed<I, V>, Single>

Source§

fn execute<'a>( _graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<I, V, D, C> LaneKernel<Indexed<I, V>, Single> for RaiseWhenErrorsOf<D, C>
where I: IndexDomain, V: ValueDomain, D: Diagnostic, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

Source§

type Output = OperandHandle<Indexed<I, V>, Single>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, V, Single>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<I, V, G, C> LaneKernel<Indexed<I, V>, Single> for RaiseWhenErrorsIn<G, C>
where I: IndexDomain, V: ValueDomain, G: ErrorGroup, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

Source§

type Output = OperandHandle<Indexed<I, V>, Single>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, V, Single>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl<I, V, E, C> LaneKernel<Indexed<I, V>, Single> for RaiseWhenErrorsWithCause<E, C>
where I: IndexDomain, V: ValueDomain, E: Error + 'static, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

Source§

type Output = OperandHandle<Indexed<I, V>, Single>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, V, Single>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

Source§

impl LaneKernel<Indexed<u32, Unit>, Single> for NodesOperation

Source§

type Output = OperandHandle<Indexed<GraphRecordAttribute, Unit>, Multiple<Unordered>>

Source§

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, EdgeIndex, Unit, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

Source§

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

Source§

impl<S: ElementShape> PartitionArity<S> for Single

Source§

fn into_elements<'a>( container: Self::Container<'a, S::Element<'a>>, ) -> BoxedIterator<'a, S::Element<'a>>
where S: 'a,

Source§

fn from_bucket<'a>( elements: Vec<S::Element<'a>>, ) -> QueryResult<Self::Container<'a, S::Element<'a>>>
where S: 'a,

Source§

impl<V: BareValueDomain> PreparedArity<Bare<V>> for Single

Source§

type Prepared<'a> = Option<Result<<V as ValueDomain>::Value<'a>, Box<Failure>>> where Bare<V>: 'a

Source§

fn prepare<'a>( container: Self::Container<'a, <Bare<V> as ElementShape>::Element<'a>>, ) -> QueryResult<Self::Prepared<'a>>
where Bare<V>: 'a,

Source§

impl<I: IndexDomain, V: ValueDomain> PreparedArity<Indexed<I, V>> for Single

Source§

type Prepared<'a> = Option<(<I as IndexDomain>::Index<'a>, Result<<V as ValueDomain>::Value<'a>, Box<Failure>>)> where Indexed<I, V>: 'a

Source§

fn prepare<'a>( container: Self::Container<'a, <Indexed<I, V> as ElementShape>::Element<'a>>, ) -> QueryResult<Self::Prepared<'a>>
where Indexed<I, V>: 'a,

Source§

impl<V> SetArity<Bare<V>> for Single
where V: BareValueDomain, for<'a> V::Value<'a>: Eq + Hash,

Source§

fn set<'a>(prepared: Self::Prepared<'a>) -> QueryResult<GrHashSet<V::Value<'a>>>
where Bare<V>: 'a,

Source§

impl<I, V> SetArity<Indexed<I, V>> for Single
where I: IndexDomain, V: ValueDomain, for<'a> V::Value<'a>: Eq + Hash,

Source§

fn set<'a>(prepared: Self::Prepared<'a>) -> QueryResult<GrHashSet<V::Value<'a>>>
where Indexed<I, V>: 'a,

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V