Struct MappedQueryResource 

pub struct MappedQueryResource<T, U, E> { /* private fields */ }

Available on crate feature core only.

A mapped view over a QueryResource that applies a SelectTransform.

This implements the “select” pattern: multiple consumers can derive different views from the same underlying cached data, each with their own MappedQueryResource holding a different transform function. The source data is shared, so there is no duplication.

Type parameters

• T: The source data type (the cached query result).
• U: The projected output type (the derived view).
• E: The error type (carried through for API consistency).

Storage

Source data is held as Option<Arc<T>> (audit #20) so that cloning a MappedQueryResource (e.g. for derived views) is a cheap Arc::clone rather than a full copy of T. Arc<T> is Send + Sync exactly when T is, so the existing bounds are preserved.

Implementations

impl<T, U, E> MappedQueryResource<T, U, E>

pub fn new( source_data: Option<Arc<T>>, transform: SelectTransform<T, U>, ) -> Self

Create a new mapped resource.

Takes ownership of the source data as Option<Arc<T>> (audit #20). For the common case of constructing from a plain T, wrap it with Some(Arc::new(t)).

pub fn data(&self) -> Option<U>

Apply the transform to get the selected data.

Note (audit #3): This re-applies the transform closure on every call. MappedQueryResource is a derived view with no separate output cache — it stores only the source data and the transform function. If the transform is expensive and you need the result multiple times in a single render pass (e.g., once for display and once for an equality check), cache the result in a local variable:

use gpui_query::core::{MappedQueryResource, SelectTransform};

let transform = SelectTransform::new(|v: &Vec<i32>| v.len());
let mapped = MappedQueryResource::<_, usize, ()>::new(Some(std::sync::Arc::new(vec![1, 2, 3])), transform);
let data = mapped.data(); // transform runs once
assert_eq!(data, Some(3));
// use `data` freely below

For lightweight transforms (field access, counting, simple projections) the cost is negligible and no caching is needed.

pub fn has_data(&self) -> bool

Whether source data exists.

pub fn source_data(&self) -> Option<&T>

Read-only access to the source data.

Returns Option<&T> by dereferencing the stored Arc<T> (audit #20). Keeping the &T return type (rather than &Arc<T>) is the least disruptive choice: existing callers compare the pointed-to T and do not need to change. Used by the hook layer to detect when the source has changed before re-storing.

pub fn source_arc(&self) -> Option<Arc<T>>

Cheaply hand out the cached source Arc<T> as an owned value.

Returns Option<Arc<T>> via a refcount bump (Arc::clone) — no T clone. Audit H1: the hook layer uses this to compare the cached source against a fresh read WITHOUT cloning T on unchanged notifications. Because the returned Arc<T> is owned, the mapped borrow ends with this call, so a subsequent entity.read_with does not create the nested borrow that audit #115 removed.

pub fn update_source(&mut self, data: Option<Arc<T>>)

Update the source data from the underlying query resource.

Call this when the source QueryResource changes (fetch completes, cache invalidation, etc.) to keep the mapped view in sync. The transform is not applied here — it is applied lazily when data() is called. Takes Option<Arc<T>> so callers can hand over a cheap Arc::clone instead of cloning the full T (audit #20).

Trait Implementations

impl<T: Clone, U: Clone, E: Clone> Clone for MappedQueryResource<T, U, E>

fn clone(&self) -> MappedQueryResource<T, U, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, U: Debug, E: Debug> Debug for MappedQueryResource<T, U, E>

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

Formats the value using the given formatter.

impl<T: Eq, U: Eq, E: Eq> Eq for MappedQueryResource<T, U, E>

impl<T: PartialEq, U: PartialEq, E: PartialEq> PartialEq for MappedQueryResource<T, U, E>

fn eq(&self, other: &MappedQueryResource<T, U, E>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialEq, U: PartialEq, E: PartialEq> StructuralPartialEq for MappedQueryResource<T, U, E>