Skip to main content

gpui_query/core/resource/
accessors.rs

1//! Query resource read-only accessors.
2
3use crate::core::{
4    CachePolicy, QueryKey, QuerySignal, QueryStatus, QueryTimestamp, RequestId, RequestPolicy,
5    RetryPolicy,
6};
7
8use super::QueryResource;
9
10impl<T, E> QueryResource<T, E> {
11    /// Whether the resource is currently loading.
12    pub fn is_loading(&self) -> bool {
13        self.status.is_loading()
14    }
15
16    /// Whether the resource is pending (no data yet).
17    pub fn is_pending(&self) -> bool {
18        self.status.is_pending()
19    }
20
21    /// The cache key.
22    pub fn key(&self) -> &QueryKey {
23        &self.key
24    }
25
26    /// Current status.
27    pub fn status(&self) -> QueryStatus {
28        self.status
29    }
30
31    /// Current data, if loaded.
32    pub fn data(&self) -> Option<&T> {
33        self.data.as_ref()
34    }
35
36    /// Current error, if any.
37    pub fn error(&self) -> Option<&E> {
38        self.error.as_ref()
39    }
40
41    /// Active request id, if a request is in flight.
42    pub fn active_request_id(&self) -> Option<RequestId> {
43        self.active_request_id
44    }
45
46    /// The cache policy.
47    pub fn cache_policy(&self) -> CachePolicy {
48        self.cache_policy
49    }
50
51    /// The request policy.
52    pub fn request_policy(&self) -> RequestPolicy {
53        self.request_policy
54    }
55
56    /// When the current request started (ms since UNIX epoch).
57    pub fn started_at_ms(&self) -> Option<u64> {
58        self.started_at.map(QueryTimestamp::as_millis)
59    }
60
61    /// When data was last updated (ms since UNIX epoch).
62    pub fn last_updated_at_ms(&self) -> Option<u64> {
63        self.last_updated_at.map(QueryTimestamp::as_millis)
64    }
65
66    /// Total cache hits.
67    pub fn cache_hits(&self) -> u64 {
68        self.cache_hits
69    }
70
71    /// Total cancelled requests.
72    pub fn cancelled_count(&self) -> u64 {
73        self.cancelled_count
74    }
75
76    /// Total ignored (stale) results.
77    pub fn ignored_results(&self) -> u64 {
78        self.ignored_results
79    }
80
81    /// Whether data exists.
82    pub fn has_data(&self) -> bool {
83        self.data.is_some()
84    }
85
86    /// The cancellation signal, if a request is in flight.
87    pub fn signal(&self) -> Option<&QuerySignal> {
88        self.signal.as_ref()
89    }
90
91    /// Mutable reference to the cancellation signal.
92    ///
93    /// Currently only exercised by tests; gated accordingly to avoid
94    /// surfacing an unused public API (N23).
95    #[cfg(test)]
96    pub(crate) fn signal_mut(&mut self) -> Option<&mut QuerySignal> {
97        self.signal.as_mut()
98    }
99
100    /// Previous data (saved during optimistic updates for rollback).
101    pub fn previous_data(&self) -> Option<&T> {
102        self.previous_data.as_ref()
103    }
104
105    /// Current retry count.
106    pub fn retry_count(&self) -> u32 {
107        self.retry_count
108    }
109
110    /// The retry policy.
111    pub fn retry_policy(&self) -> &RetryPolicy {
112        &self.retry_policy
113    }
114
115    /// Increment the retry counter.
116    pub fn increment_retry(&mut self) {
117        self.retry_count = self.retry_count.saturating_add(1);
118    }
119
120    /// Set the retry policy.
121    pub fn set_retry_policy(&mut self, policy: RetryPolicy) {
122        self.retry_policy = policy;
123    }
124
125    /// Reset the retry counter to zero.
126    pub fn reset_retry_count(&mut self) {
127        self.retry_count = 0;
128    }
129
130    /// Set the cache policy.
131    ///
132    /// This allows policy updates on existing resources when `use_query` is
133    /// called with the same key but different policies (e.g., a different TTL).
134    pub fn set_cache_policy(&mut self, policy: CachePolicy) {
135        self.cache_policy = policy;
136    }
137
138    /// Set the request policy.
139    ///
140    /// This allows policy updates on existing resources when `use_query` is
141    /// called with the same key but different request behavior.
142    pub fn set_request_policy(&mut self, policy: RequestPolicy) {
143        self.request_policy = policy;
144    }
145}