pub struct LocatedDetection<T> { /* private fields */ }Expand description
A CLASSIFICATION AND ITS PLACE — what was found, how sure the finder was, and WHERE.
┌─ bbox ───────────┐
│ │ detection: "person" @ 0.94
│ ● │
└──────────────────┘§THE BOX IS REQUIRED, and that is the ruling this type exists to state
There is no Option here and there will be none. A located detection whose box went missing is
not a located detection — it is a Detection, which is a type this house already has. One
shape with an optional box would make a whole-frame classification and a subject detection
whose geometry was lost the same value, so every consumer reading a location would carry a
branch that says nothing, and no query could tell the two populations apart.
So the pairing is avanalyze’s own, whose contract calls it a classification bound to a
bounding box: the shape used for both human and animal subjects, and whose constructor is
INFALLIBLE for the reason this one is — both halves have already been validated by their own
constructors.
§GENERIC over the GEOMETRY component, and over nothing else
T is what the box is measured in, exactly as it is for BoundingBox<T> — a normalized frame
writes LocatedDetection<NormCoord>, a raster pipeline LocatedDetection<u32>, a metric one
LocatedDetection<f64>. The openness is the geometry family’s and this type inherits it whole:
nothing here has an opinion about a unit it was never told.
There is no second parameter for the confidence’s width, and the reason is
Detection’s own: the half that holds the confidence names Score rather than
taking a width, so this type has one axis to be generic over and it is the geometry’s. See
Detection, where the door that a second parameter would come through is named.
NO DEFAULT TYPE PARAMETER. LocatedDetection bare does not compile, on the ruling
Confidence<S> set and BoundingBox<T> kept: a default would make one
world the silent reading of a type whose whole subject is that the world is the caller’s to name.
§Examples
use ingraph::{BoundingBox, Detection, Label, LocatedDetection, Score};
let subject = LocatedDetection::new(
Detection::new(Label::new("person").unwrap(), Score::new(0.94).unwrap()),
BoundingBox::try_unit(0.1, 0.2, 0.3, 0.6).unwrap(),
);
assert_eq!(subject.label().as_str(), "person");
assert_eq!(subject.bbox().width().get(), 0.3);
// The same shape in a raster world, measured in pixels.
let pixels = LocatedDetection::new(
Detection::new(Label::new("cat").unwrap(), Score::new(0.5).unwrap()),
BoundingBox::new(12_u32, 40, 200, 150),
);
assert_eq!(pixels.bbox().height(), 150);Implementations§
Source§impl<T> LocatedDetection<T>
impl<T> LocatedDetection<T>
Sourcepub const fn new(detection: Detection, bbox: BoundingBox<T>) -> Self
pub const fn new(detection: Detection, bbox: BoundingBox<T>) -> Self
A classification paired with the rectangle it was found in.
INFALLIBLE, because both halves have already been validated by their own constructors: a
Detection holds a non-empty label and a confidence inside [0.0, 1.0], and whatever rules
the box has are the ones its own component and its own instantiation checked. This level adds
no rule ACROSS the two, there being none to add — a label says nothing about where a rectangle
may be.
Sourcepub const fn detection(&self) -> &Detection
pub const fn detection(&self) -> &Detection
The classification half — the word and the confidence.
Sourcepub const fn bbox(&self) -> &BoundingBox<T>
pub const fn bbox(&self) -> &BoundingBox<T>
The geometry half — where it was found.
Sourcepub const fn label(&self) -> &Label
pub const fn label(&self) -> &Label
The word that was put on the subject — the classification’s, reached without naming it.
Sourcepub const fn confidence(&self) -> Score
pub const fn confidence(&self) -> Score
How confident the classifier was — the classification’s, reached without naming it.
impl<T> LocatedDetection<T>
A classification and the rectangle it was found in.
All three fields are NON-NULL, and the third is the type’s whole subject: a located detection has
a box, which is what distinguishes it from a Detection.
The classification’s two fields are FLATTENED here rather than nested behind a detection
object, so reading a finding’s word costs no extra selection set — the shape the sibling house
takes, for the same reason.
Trait Implementations§
Source§impl<'a, R, T> Assemble<'a, R> for LocatedDetection<T>
Available on crate feature sqlx only.AND ITS COLUMNS BACK IN — the classification flat under the address it was given, then the
box beneath its own seat.
impl<'a, R, T> Assemble<'a, R> for LocatedDetection<T>
sqlx only.AND ITS COLUMNS BACK IN — the classification flat under the address it was given, then the box beneath its own seat.
assembled_flattened is what makes the first half read at the
holder’s own level, which is the read side of flattened and the same pairing every spliced
part in this crate has. Every refusal this row can produce is a half’s own — an empty label, a
confidence outside the interval, a coordinate outside the frame — each naming the column that
held it.
Source§impl<Db, T> Carrier<Db> for LocatedDetection<T>
Available on crate feature sqlx only.SEVEN BINDS OUT — the detection’s two, then the box’s five, with the one comma this level
owns between them.
impl<Db, T> Carrier<Db> for LocatedDetection<T>
sqlx only.SEVEN BINDS OUT — the detection’s two, then the box’s five, with the one comma this level owns between them.
Each half writes its own internal commas, which is the arrangement Carrier
documents: how many columns a value spans is the value’s own answer, so a composite pushes
several placeholders with its own separators and the caller counts FIELDS. The derived column is
the box’s own fifth push and nothing here computes it.
AND SIX FOR A STRUCTURAL JUDGMENT, which is this row’s half of the 2026-08-30 pairing: the value bind DELEGATES to each half’s, so the box leaves its index leaf out where it always does and the classification — which has none — binds the same two either way. A holder that took the default here would bind seven placeholders under a six-column row value, which is a statement no engine parses.
Source§fn push_bind(&self, qb: &mut QueryBuilder<Db>)
fn push_bind(&self, qb: &mut QueryBuilder<Db>)
qb. Read moreSource§fn push_value_bind(&self, qb: &mut QueryBuilder<Db>)
fn push_value_bind(&self, qb: &mut QueryBuilder<Db>)
Source§impl<T: Clone> Clone for LocatedDetection<T>
impl<T: Clone> Clone for LocatedDetection<T>
impl<T: CollectionElement> CollectionElement for LocatedDetection<T>
THE ADMISSION, and it DELEGATES to the geometry half: a located detection is one element of a collection exactly where its box is.
Vec<LocatedDetection<NormCoord>> is what a detection pass produces — every face in a frame,
every subject in a photo — so this row is the one an edge table of findings needs. The
classification half is admitted unconditionally (Detection’s own row), so the box is the only
half with a question left to ask.
Source§impl<T: ColumnEq> ColumnEq for LocatedDetection<T>
A located detection is one column value when its classification and its region both are — the
classification through its own row, so the box’s derived area plays no part in what the box
itself compares equal.
impl<T: ColumnEq> ColumnEq for LocatedDetection<T>
A located detection is one column value when its classification and its region both are — the classification through its own row, so the box’s derived area plays no part in what the box itself compares equal.
Source§impl<T: ColumnKind> ColumnKind for LocatedDetection<T>
The SIX columns a located detection spans: the detection’s two, FLATTENED, then the box’s
four under their own name.
impl<T: ColumnKind> ColumnKind for LocatedDetection<T>
The SIX columns a located detection spans: the detection’s two, FLATTENED, then the box’s four under their own name.
§The classification FLATTENS and the geometry does not, and neither side chose that
The detection’s entry is flattened, which lends no name, so a located detection at subject
reaches subject_label and subject_confidence — the same two columns a bare Detection at
subject occupies. Naming it would have given subject_detection_label, which says one word
twice and buys nothing: this type holds exactly one classification, so there is nothing for that
segment to disambiguate. That is
DetectedLanguage’s own arrangement, in the other
family’s spelling.
The box KEEPS its name for TimeRanged<T>’s reason, and it is the stronger
of the two: BoundingBox<T>’s own segments are x, y, width, height, and a splice would
put four independent names into the holder’s namespace beside a label and a confidence. Here
nothing collides today — but the bbox segment is what makes a collision UNREPRESENTABLE rather
than merely absent, and it costs one segment.
§The LEAF GUARD is inherited rather than restated
BoundingBox<T>’s own SEGMENTS asserts that its component spans one column, and this row reads
that const — so a composite component meets the box’s own E0080, naming the box’s rule, at the
place a reader would go looking for it. A second assertion here would be a second sentence about
one fact.
use ingraph::{ColumnKind, LocatedDetection, TimeRange};
const _: usize = <LocatedDetection<TimeRange> as ColumnKind>::SEGMENTS.len();Source§const SEGMENTS: &'static [ColumnShape]
const SEGMENTS: &'static [ColumnShape]
Source§const ORDER: &'static [OrderLevel] = ORDER
const ORDER: &'static [OrderLevel] = ORDER
Source§impl<T> CompositeFilterMarker for LocatedDetection<T>where
T: DefaultMarker,
What guards a LocatedDetection<T> column — its own filter at both seats.
impl<T> CompositeFilterMarker for LocatedDetection<T>where
T: DefaultMarker,
What guards a LocatedDetection<T> column — its own filter at both seats.
The component’s filter is resolved through PayloadFilter<T> rather than
listed, which is what keeps this row FRAMEWORK-OPEN: a geometry component declared in a
downstream crate reaches this filter by having a default marker, which every column type already
has. That is BoundingBox<T>’s own row, read one level up, and it reads the same alias rather
than writing a second.
Source§type Filter = LocatedDetectionFilter<<<T as DefaultMarker>::Marker as ToGraphqlFilter>::Filter>
type Filter = LocatedDetectionFilter<<<T as DefaultMarker>::Marker as ToGraphqlFilter>::Filter>
Source§type ColumnFilter = LocatedDetectionFilter<<<T as DefaultMarker>::Marker as ToGraphqlFilter>::Filter>
type ColumnFilter = LocatedDetectionFilter<<<T as DefaultMarker>::Marker as ToGraphqlFilter>::Filter>
Source§impl<T> ContainerType for LocatedDetection<T>
Available on crate feature async-graphql only.
impl<T> ContainerType for LocatedDetection<T>
async-graphql only.Source§async fn resolve_field(&self, ctx: &Context<'_>) -> ServerResult<Option<Value>>
async fn resolve_field(&self, ctx: &Context<'_>) -> ServerResult<Option<Value>>
boxed-trait only.async_graphql::Value. Read moreSource§async fn find_entity(
&self,
ctx: &Context<'_>,
params: &Value,
) -> ServerResult<Option<Value>>
async fn find_entity( &self, ctx: &Context<'_>, params: &Value, ) -> ServerResult<Option<Value>>
boxed-trait only.Source§fn collect_all_fields<'a>(
&'a self,
ctx: &ContextBase<'a, &'a Positioned<SelectionSet>>,
fields: &mut Fields<'a>,
) -> Result<(), ServerError>
fn collect_all_fields<'a>( &'a self, ctx: &ContextBase<'a, &'a Positioned<SelectionSet>>, fields: &mut Fields<'a>, ) -> Result<(), ServerError>
Source§impl<T: CursorValue> CursorValue for LocatedDetection<T>
THE KEYSET POSITION — the classification, then the box, each behind its own four-byte length.
impl<T: CursorValue> CursorValue for LocatedDetection<T>
THE KEYSET POSITION — the classification, then the box, each behind its own four-byte length.
Detection’s row one file over carries the argument, and it is unchanged one level up: this
holder’s first member is variable-width, so there is no constant split point and the framing is
the framework’s own write_member pair rather than a delimiter
invented here. The box RIDES that framing unchanged whatever its component’s width is — it is
handed exactly the bytes it wrote, which is the contract its own division already depends on.
The ORDER the bytes encode is the columns’ and not a claim about findings, for the reason neither
this type nor either of its halves publishes an Ord.
Source§impl<T: Debug> Debug for LocatedDetection<T>
impl<T: Debug> Debug for LocatedDetection<T>
Source§impl<T: DefaultMarker> DefaultMarker for LocatedDetection<T>
The interpretation a LocatedDetection<T> field is read under — the COMPOSITE reading, because
the value occupies columns of its own and all six can be absent together.
impl<T: DefaultMarker> DefaultMarker for LocatedDetection<T>
The interpretation a LocatedDetection<T> field is read under — the COMPOSITE reading, because
the value occupies columns of its own and all six can be absent together.
Source§type Marker = CompositeMarker<LocatedDetection<T>>
type Marker = CompositeMarker<LocatedDetection<T>>
Source§impl<T: DefaultMarker> DefaultVecMarker for LocatedDetection<T>
A COLLECTION of located detections is asked through the QUANTIFIERS alone — Detection’s
own ruling, which this type inherits along with the float that makes it.
impl<T: DefaultMarker> DefaultVecMarker for LocatedDetection<T>
A COLLECTION of located detections is asked through the QUANTIFIERS alone — Detection’s
own ruling, which this type inherits along with the float that makes it.
any carries the whole LocatedDetectionFilter, so a person was detected confidently in the
top-left quadrant is ONE element question — which is the shape that matters here and the one a
per-column reading could never state: asked of the collection separately, the label, the
confidence and the box would each be answered by a different finding.
Source§type Marker = QuantifiedMarker<Vec<LocatedDetection<T>>>
type Marker = QuantifiedMarker<Vec<LocatedDetection<T>>>
Vec of this element type is read under by default. Read moreimpl<T: Eq> Eq for LocatedDetection<T>
Source§impl<T: Hash> Hash for LocatedDetection<T>
impl<T: Hash> Hash for LocatedDetection<T>
impl<T> ObjectType for LocatedDetection<T>
async-graphql only.Source§impl<T: ColumnKind + Copy> OrderLeaves for LocatedDetection<T>
The six VALUE leaves, the geometry’s four delegated, and None for the derived seventh.
impl<T: ColumnKind + Copy> OrderLeaves for LocatedDetection<T>
The six VALUE leaves, the geometry’s four delegated, and None for the derived seventh.
Source§impl<T> OutputType for LocatedDetection<T>
Available on crate feature async-graphql only.
impl<T> OutputType for LocatedDetection<T>
async-graphql only.Source§fn create_type_info(registry: &mut Registry) -> String
fn create_type_info(registry: &mut Registry) -> String
Source§async fn resolve(
&self,
ctx: &ContextSelectionSet<'_>,
_field: &Positioned<Field>,
) -> ServerResult<Value>
async fn resolve( &self, ctx: &ContextSelectionSet<'_>, _field: &Positioned<Field>, ) -> ServerResult<Value>
boxed-trait only.async_graphql::Value.Source§fn qualified_type_name() -> String
fn qualified_type_name() -> String
Source§impl<T: PartialEq> PartialEq for LocatedDetection<T>
impl<T: PartialEq> PartialEq for LocatedDetection<T>
Source§impl<Db, T> StoredAs<Db> for LocatedDetection<T>
The DECLARED half — SEVEN words, the detection’s two and the box’s five, each read off the
half that owns it.
impl<Db, T> StoredAs<Db> for LocatedDetection<T>
The DECLARED half — SEVEN words, the detection’s two and the box’s five, each read off the half that owns it.
The arity is FIXED at seven, and both halves are why: a Detection is two leaves by
construction, and a BoundingBox<T> is five — four it holds and one it derives — because its
own leaf guard says so. That is what puts this type on the side of the boundary
TimeRanged<T> records rather than under it — a generic PAYLOAD has a word
count no length position can name, and a generic COMPONENT under a leaf guard has one the impl
can write down.
The FIFTH box word is the derived area’s, read off the box’s own row like the other four. This type states nothing about it and could not: what a derived column is stored as is the house that derives it’s answer.
impl<T: PartialEq> StructuralPartialEq for LocatedDetection<T>
Source§impl<T, CF, Db> ToDatabaseComparison<LocatedDetection<T>, Db> for LocatedDetectionFilter<CF>where
Db: Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlDetectionComparison<Db>: ComplexComparison<Db>,
CF: ToDatabaseComparison<T, Db>,
Available on crate feature sqlx only.THE ROUTING ROW for a located-detection column — reached by a
LocatedDetectionFilter over whatever filter the geometry
component’s own family routes with.
impl<T, CF, Db> ToDatabaseComparison<LocatedDetection<T>, Db> for LocatedDetectionFilter<CF>where
Db: Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlDetectionComparison<Db>: ComplexComparison<Db>,
CF: ToDatabaseComparison<T, Db>,
sqlx only.THE ROUTING ROW for a located-detection column — reached by a
LocatedDetectionFilter over whatever filter the geometry
component’s own family routes with.
Source§type Comparison = SqlLocatedDetectionComparison<T, <CF as ToDatabaseComparison<T, Db>>::Comparison, Db>
type Comparison = SqlLocatedDetectionComparison<T, <CF as ToDatabaseComparison<T, Db>>::Comparison, Db>
V and lowering for Db.Source§impl<T> ToGraphqlOutput for LocatedDetection<T>
Available on crate feature async-graphql only.The crossing OUT — a BORROW, resolved by the #[Object] above.
impl<T> ToGraphqlOutput for LocatedDetection<T>
async-graphql only.The crossing OUT — a BORROW, resolved by the #[Object] above.
Source§type Output<'a> = &'a LocatedDetection<T>
where
T: 'a
type Output<'a> = &'a LocatedDetection<T> where T: 'a
M crosses into an OUTPUT position as.Source§fn to_graphql_output(marked: &Self) -> &Self
fn to_graphql_output(marked: &Self) -> &Self
Source§impl<T> TypeName for LocatedDetection<T>
Available on crate feature async-graphql only.LocatedDetection<T> publishes LocatedDetection before the geometry COMPONENT’s own published
name.
impl<T> TypeName for LocatedDetection<T>
async-graphql only.LocatedDetection<T> publishes LocatedDetection before the geometry COMPONENT’s own published
name.
The bound is ToGraphqlOutput rather than OutputType, which is this crate’s crossing map
read where async-graphql would have read its own: a component reaches the wire through the form
its row names, and that form is what carries a published name. 'static is what makes
Output<'static> nameable at all — a name is asked for with no value in hand.
Auto Trait Implementations§
impl<T> !Freeze for LocatedDetection<T>
impl<T> RefUnwindSafe for LocatedDetection<T>where
BoundingBox<T>: RefUnwindSafe,
impl<T> Send for LocatedDetection<T>where
BoundingBox<T>: Send,
impl<T> Sync for LocatedDetection<T>where
BoundingBox<T>: Sync,
impl<T> Unpin for LocatedDetection<T>where
BoundingBox<T>: Unpin,
impl<T> UnsafeUnpin for LocatedDetection<T>where
BoundingBox<T>: UnsafeUnpin,
impl<T> UnwindSafe for LocatedDetection<T>where
BoundingBox<T>: UnwindSafe,
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<Db, T> DialectCursor<Db> for Twhere
T: CursorValue,
impl<Db, T> DialectCursor<Db> for Twhere
T: CursorValue,
Source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
Source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be
downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.Source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further
downcast into Rc<ConcreteType> where ConcreteType implements Trait.Source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &Any’s vtable from &Trait’s.Source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &mut Any’s vtable from &mut Trait’s.Source§impl<T> DowncastSend for T
impl<T> DowncastSend for T
Source§impl<T> DowncastSync for T
impl<T> DowncastSync for T
Source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
Source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key and return true if they are equal.Source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
Source§impl<T> FmtForward for T
impl<T> FmtForward for T
Source§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self to use its Binary implementation when Debug-formatted.Source§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self to use its Display implementation when
Debug-formatted.Source§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self to use its LowerExp implementation when
Debug-formatted.Source§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self to use its LowerHex implementation when
Debug-formatted.Source§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self to use its Octal implementation when Debug-formatted.Source§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self to use its Pointer implementation when
Debug-formatted.Source§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self to use its UpperExp implementation when
Debug-formatted.Source§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self to use its UpperHex implementation when
Debug-formatted.impl<T> Fruit for T
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
Source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
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 moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
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 moreSource§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
Source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
Source§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read moreSource§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read moreSource§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
Source§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
Source§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self, then passes self.as_ref() into the pipe function.Source§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self, then passes self.as_mut() into the pipe
function.Source§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self, then passes self.deref() into the pipe function.Source§impl<T> Pointable for T
impl<T> Pointable for T
impl<K> PositionKey for K
impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
impl<T> RootKey for T
Source§impl<T> Tap for T
impl<T> Tap for T
Source§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B> of a value. Read moreSource§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B> of a value. Read moreSource§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R> view of a value. Read moreSource§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R> view of a value. Read moreSource§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target of a value. Read moreSource§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target of a value. Read moreSource§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap() only in debug builds, and is erased in release builds.Source§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut() only in debug builds, and is erased in release
builds.Source§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref() only in debug builds, and is erased in release
builds.Source§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut() only in debug builds, and is erased in release
builds.Source§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref() only in debug builds, and is erased in release
builds.Source§impl<T> WireScore for Twhere
T: ToGraphqlOutput + Send + Sync + 'static,
<T as ToGraphqlOutput>::Output<'a>: for<'a> OutputType,
impl<T> WireScore for Twhere
T: ToGraphqlOutput + Send + Sync + 'static,
<T as ToGraphqlOutput>::Output<'a>: for<'a> OutputType,
Source§type Wire<'a> = <T as ToGraphqlOutput>::Output<'a>
where
T: 'a
type Wire<'a> = <T as ToGraphqlOutput>::Output<'a> where T: 'a
async-graphql only.OutputType — the BACKEND’s demand, made where the
backend spends the form.Source§fn wire_score(&self) -> <T as WireScore>::Wire<'_>
fn wire_score(&self) -> <T as WireScore>::Wire<'_>
async-graphql only.