Skip to main content

LocatedDetection

Struct LocatedDetection 

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

Source

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.

Source

pub const fn detection(&self) -> &Detection

The classification half — the word and the confidence.

Source

pub const fn bbox(&self) -> &BoundingBox<T>

The geometry half — where it was found.

Source

pub const fn label(&self) -> &Label

The word that was put on the subject — the classification’s, reached without naming it.

Source

pub const fn confidence(&self) -> Score

How confident the classifier was — the classification’s, reached without naming it.

Source§

impl<T> LocatedDetection<T>
where T: ToGraphqlOutput + Copy + Send + Sync + 'static, for<'a> T::Output<'a>: OutputType,

This impl block contains no public items.

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>
where R: Row, Detection: Assemble<'a, R>, BoundingBox<T>: Assemble<'a, R>,

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.

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§

fn assemble(row: &'a R, under: Option<&Path<'_>>) -> Result<Self>

Read this value out of row, under the segments under names. Read more
Source§

impl<Db, T> Carrier<Db> for LocatedDetection<T>
where Db: Database, Detection: Carrier<Db>, BoundingBox<T>: Carrier<Db>,

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.

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

Push this value’s placeholder and bound argument onto qb. Read more
Source§

fn push_value_bind(&self, qb: &mut QueryBuilder<Db>)

Push this value’s placeholders and bound arguments for its VALUE columns alone — the DERIVED leaves left out. Read more
Source§

impl<T: Clone> Clone for LocatedDetection<T>

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

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.

Source§

fn column_eq(&self, other: &Self) -> bool

Whether self and other are the same stored value.
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.

§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]

What this type spans beneath the field that names it. Read more
Source§

const ORDER: &'static [OrderLevel] = ORDER

WHICH ORDER those columns mean — the leaves an order over this type sorts by, in sequence. Read more
Source§

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>

The filter a composite column of this type gets at a ROWLESS host — the full field set.
Source§

type ColumnFilter = LocatedDetectionFilter<<<T as DefaultMarker>::Marker as ToGraphqlFilter>::Filter>

The filter a composite column of this type gets at a ROW-HOLDING host — the stored subset.
Source§

impl<T> ContainerType for LocatedDetection<T>
where T: ToGraphqlOutput + Copy + Send + Sync + 'static, for<'a> T::Output<'a>: OutputType,

Available on crate feature async-graphql only.
Source§

async fn resolve_field(&self, ctx: &Context<'_>) -> ServerResult<Option<Value>>

Available on non-crate feature boxed-trait only.
Resolves a field value and outputs it as a json value async_graphql::Value. Read more
Source§

async fn find_entity( &self, ctx: &Context<'_>, params: &Value, ) -> ServerResult<Option<Value>>

Available on non-crate feature boxed-trait only.
Find the GraphQL entity with the given name from the parameter. Read more
Source§

fn collect_all_fields<'a>( &'a self, ctx: &ContextBase<'a, &'a Positioned<SelectionSet>>, fields: &mut Fields<'a>, ) -> Result<(), ServerError>
where Self: Send + Sync,

Collect all the fields of the container that are queried in the selection set. Read more
Source§

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§

fn write_cursor(&self, out: &mut Vec<u8>)

Append this value’s cursor bytes to out.
Source§

fn read_cursor(bytes: &[u8]) -> Option<Self>

The value bytes holds, or None where they are not this type’s encoding. Read more
Source§

impl<T: Debug> Debug for LocatedDetection<T>

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
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.

Source§

type Marker = CompositeMarker<LocatedDetection<T>>

The interpretation this type is read under by default.
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.

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

The interpretation a Vec of this element type is read under by default. Read more
Source§

impl<T: Eq> Eq for LocatedDetection<T>

Source§

impl<T: Hash> Hash for LocatedDetection<T>

Source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
Source§

impl<T> ObjectType for LocatedDetection<T>
where T: ToGraphqlOutput + Copy + Send + Sync + 'static, for<'a> T::Output<'a>: OutputType,

Available on crate feature 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.

Source§

type Leaf = LocatedDetectionLeaf<T>

The value ONE of this type’s order levels compares. Read more
Source§

fn leaf(&self, at: usize) -> Option<LocatedDetectionLeaf<T>>

The at-th LEAF’s value, or None where this value has none there. Read more
Source§

impl<T> OutputType for LocatedDetection<T>
where T: ToGraphqlOutput + Copy + Send + Sync + 'static, for<'a> T::Output<'a>: OutputType,

Available on crate feature async-graphql only.
Source§

fn type_name() -> Cow<'static, str>

Type the name.
Source§

fn create_type_info(registry: &mut Registry) -> String

Create type information in the registry and return qualified typename.
Source§

async fn resolve( &self, ctx: &ContextSelectionSet<'_>, _field: &Positioned<Field>, ) -> ServerResult<Value>

Available on non-crate feature boxed-trait only.
Resolve an output value to async_graphql::Value.
Source§

fn qualified_type_name() -> String

Qualified typename.
Source§

fn introspection_type_name(&self) -> Cow<'static, str>

Introspection type name Read more
Source§

impl<T: PartialEq> PartialEq for LocatedDetection<T>

Source§

fn eq(&self, other: &Self) -> bool

Equality operator ==. Read more
1.0.0 (const: unstable) · Source§

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=. Read more
Source§

impl<Db, T> StoredAs<Db> for LocatedDetection<T>
where Detection: StoredAs<Db>, BoundingBox<T>: StoredAs<Db>,

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.

Source§

const WORDS: &'static [&'static str]

One word per column this type spans, in SEGMENTS order, written in this dialect catalogue’s own reported spelling.
Source§

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.

Source§

type Comparison = SqlLocatedDetectionComparison<T, <CF as ToDatabaseComparison<T, Db>>::Comparison, Db>

The comparison a filter of this kind crosses into, holding 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.

Source§

type Output<'a> = &'a LocatedDetection<T> where T: 'a

The form a value of M crosses into an OUTPUT position as.
Source§

fn to_graphql_output(marked: &Self) -> &Self

That value, in that form. Read more
Source§

impl<T> TypeName for LocatedDetection<T>
where T: ToGraphqlOutput + Send + Sync + 'static, for<'a> T::Output<'a>: OutputType,

Available on crate feature 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.

Source§

fn type_name() -> Cow<'static, str>

Returns a GraphQL type name.

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<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> Conv for T

Source§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
Source§

impl<Db, T> DialectCursor<Db> for T
where T: CursorValue,

Source§

fn write_cursor_at(&self, out: &mut Vec<u8>)

Append this value’s cursor bytes for Db to out.
Source§

fn read_cursor_at(bytes: &[u8]) -> Option<T>

The value bytes holds at Db, or None where they are not this dialect’s encoding. Read more
Source§

impl<T> Downcast for T
where T: Any,

Source§

fn into_any(self: Box<T>) -> Box<dyn Any>

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

Converts 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)

Converts &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)

Converts &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
where T: Any + Send,

Source§

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

Source§

fn into_any_sync(self: Box<T>) -> Box<dyn Any + Send + Sync>

Converts Box<Trait> (where Trait: DowncastSync) to Box<dyn Any + Send + Sync>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync> ⓘ

Converts Arc<Trait> (where Trait: DowncastSync) to Arc<Any>, which can then be downcast into Arc<ConcreteType> where ConcreteType implements Trait.
Source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
Source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
Source§

impl<T> FmtForward for T

Source§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
Source§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
Source§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
Source§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
Source§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
Source§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
Source§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
Source§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
Source§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Fruit for T
where T: Send + Downcast,

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
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> Pipe for T
where T: ?Sized,

Source§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
Source§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
Source§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
Source§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows 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
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows 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
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
Source§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
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<K> PositionKey for K
where K: Clone + Eq + Hash + Send + Sync,

Source§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<T> RootKey for T
where T: Clone + Eq + Hash + Send + Sync + 'static,

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> State<Identity> for T

Source§

type Output = T

The type Self projects to.
Source§

impl<T> Tap for T

Source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
Source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
Source§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
Source§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
Source§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
Source§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
Source§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
Source§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
Source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
Source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .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
where Self: BorrowMut<B>, B: ?Sized,

Calls .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
where Self: AsRef<R>, R: ?Sized,

Calls .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
where Self: AsMut<R>, R: ?Sized,

Calls .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
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T> TryConv for T

Source§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

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

Source§

type Error = !

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

fn try_from(value: U) -> Result<T, !>

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

Source§

impl<T> WireScore for T
where 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

Available on crate feature async-graphql only.
The form this score crosses into, and it is OutputType — the BACKEND’s demand, made where the backend spends the form.
Source§

fn wire_score(&self) -> <T as WireScore>::Wire<'_>

Available on crate feature async-graphql only.
This score, in that form.
Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more