Implement AnyBufferView

Signed-off-by: Michael X. Grey <mxgrey@intrinsic.ai>

Author: mxgrey

src/buffer/any_buffer.rs

@@ -165,6 +165,52 @@ impl<T: 'static + Send + Sync + Any> From<BufferKey<T>> for AnyBufferKey {
     }
 }
 
+/// Similar to [`BufferView`][crate::BufferView], but this can be unlocked with
+/// an [`AnyBufferKey`], so it can work for any buffer whose message types
+/// support serialization and deserialization.
+pub struct AnyBufferView<'a> {
+    storage: Box<dyn AnyBufferViewing + 'a>,
+    gate: &'a GateState,
+    session: Entity,
+}
+
+impl<'a> AnyBufferView<'a> {
+    /// Look at the oldest message in the buffer.
+    pub fn oldest(&self) -> Option<AnyMessageRef<'_>> {
+        self.storage.any_oldest(self.session)
+    }
+
+    /// Look at the newest message in the buffer.
+    pub fn newest(&self) -> Option<AnyMessageRef<'_>> {
+        self.storage.any_newest(self.session)
+    }
+
+    /// Borrow a message from the buffer. Index 0 is the oldest message in the buffer
+    /// while the highest index is the newest message in the buffer.
+    pub fn get(&self, index: usize) -> Option<AnyMessageRef<'_>> {
+        self.storage.any_get(self.session, index)
+    }
+
+    /// Get how many messages are in this buffer.
+    pub fn len(&self) -> usize {
+        self.storage.any_count(self.session)
+    }
+
+    /// Check if the buffer is empty.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Check whether the gate of this buffer is open or closed.
+    pub fn gate(&self) -> Gate {
+        self.gate
+            .map
+            .get(&self.session)
+            .copied()
+            .unwrap_or(Gate::Open)
+    }
+}
+
 /// Similar to [`BufferMut`][crate::BufferMut], but this can be unlocked with an
 /// [`AnyBufferKey`], so it can work for any buffer regardless of the data type
 /// inside.
@@ -198,7 +244,7 @@ impl<'w, 's, 'a> AnyBufferMut<'w, 's, 'a> {
     }
 
     /// Borrow a message from the buffer. Index 0 is the oldest message in the buffer
-    /// with the highest index being the newest message in the buffer.
+    /// while the highest index is the newest message in the buffer.
     pub fn get(&self, index: usize) -> Option<AnyMessageRef<'_>> {
         self.storage.any_get(self.session, index)
     }
@@ -381,6 +427,15 @@ impl<'w, 's, 'a> Drop for AnyBufferMut<'w, 's, 'a> {
 /// This trait allows [`World`] to give you access to any buffer using an
 /// [`AnyBufferKey`].
 pub trait AnyBufferWorldAccess {
+    /// Call this to get read-only access to any buffer.
+    ///
+    /// For technical reasons this requires direct [`World`] access, but you can
+    /// do other read-only queries on the world while holding onto the
+    /// [`AnyBufferView`].
+    fn any_buffer_view<'a>(
+        &self,
+        key: &AnyBufferKey,
+    ) -> Result<AnyBufferView<'_>, BufferError>;
 
     /// Call this to get mutable access to any buffer.
     ///
@@ -394,6 +449,13 @@ pub trait AnyBufferWorldAccess {
 }
 
 impl AnyBufferWorldAccess for World {
+    fn any_buffer_view<'a>(
+        &self,
+        key: &AnyBufferKey,
+    ) -> Result<AnyBufferView<'_>, BufferError> {
+        key.interface.create_any_buffer_view(key, self)
+    }
+
     fn any_buffer_mut<U>(
         &mut self,
         key: &AnyBufferKey,
@@ -488,6 +550,28 @@ impl std::ops::RangeBounds<usize> for AnyRange {
 
 pub type AnyMessageRef<'a> = &'a (dyn Any + 'static + Send + Sync);
 
+impl<T: 'static + Send + Sync + Any> AnyBufferViewing for &'_ BufferStorage<T> {
+    fn any_count(&self, session: Entity) -> usize {
+        self.count(session)
+    }
+
+    fn any_oldest<'a>(&'a self, session: Entity) -> Option<AnyMessageRef<'a>> {
+        self.oldest(session).map(to_any_ref)
+    }
+
+    fn any_newest<'a>(&'a self, session: Entity) -> Option<AnyMessageRef<'a>> {
+        self.newest(session).map(to_any_ref)
+    }
+
+    fn any_get<'a>(&'a self, session: Entity, index: usize) -> Option<AnyMessageRef<'a>> {
+        self.get(session, index).map(to_any_ref)
+    }
+
+    fn any_message_type(&self) -> TypeId {
+        TypeId::of::<T>()
+    }
+}
+
 impl<T: 'static + Send + Sync + Any> AnyBufferViewing for Mut<'_, BufferStorage<T>> {
     fn any_count(&self, session: Entity) -> usize {
         self.count(session)
@@ -644,6 +728,12 @@ pub(crate) trait AnyBufferAccessInterface {
         session: Entity,
     ) -> Result<AnyMessage, OperationError>;
 
+    fn create_any_buffer_view<'a>(
+        &self,
+        key: &AnyBufferKey,
+        world: &'a World,
+    ) -> Result<AnyBufferView<'a>, BufferError>;
+
     fn create_any_buffer_access_mut_state(
         &self,
         world: &mut World,
@@ -702,6 +792,21 @@ impl<T: 'static + Send + Sync + Any> AnyBufferAccessInterface for AnyBufferAcces
         entity_mut.pull_from_buffer::<T>(session).map(to_any_message)
     }
 
+    fn create_any_buffer_view<'a>(
+        &self,
+        key: &AnyBufferKey,
+        world: &'a World,
+    ) -> Result<AnyBufferView<'a>, BufferError> {
+        let buffer_ref = world.get_entity(key.buffer).ok_or(BufferError::BufferMissing)?;
+        let storage = buffer_ref.get::<BufferStorage<T>>().ok_or(BufferError::BufferMissing)?;
+        let gate = buffer_ref.get::<GateState>().ok_or(BufferError::BufferMissing)?;
+        Ok(AnyBufferView {
+            storage: Box::new(storage),
+            gate,
+            session: key.session
+        })
+    }
+
     fn create_any_buffer_access_mut_state(
         &self,
         world: &mut World,
@@ -865,9 +970,7 @@ mod tests {
         In(key): In<AnyBufferKey>,
         world: &mut World,
     ) -> usize {
-        world.any_buffer_mut(&key, |access| {
-            access.len()
-        }).unwrap()
+        world.any_buffer_view(&key).unwrap().len()
     }
 
     #[test]

src/buffer/json_buffer.rs

@@ -37,7 +37,7 @@ use smallvec::SmallVec;
 
 use crate::{
     AnyBufferAccessImpl, AnyBufferAccessInterface, AnyBuffer, AnyBufferKey,
-    AnyRange, Buffer, BufferAccessors, BufferAccess, BufferKey, BufferKeyBuilder,
+    AnyRange, Buffer, BufferAccessors, BufferKey, BufferKeyBuilder,
     BufferAccessLifecycle, BufferAccessMut, BufferError, BufferStorage, Builder,
     DrainBuffer, OperationError, OperationResult, InspectBuffer, ManageBuffer,
     Gate, GateState, NotifyBufferUpdate, Bufferable, Buffered, OrBroken, Joined,
@@ -177,7 +177,6 @@ impl From<JsonBufferKey> for AnyBufferKey {
 pub struct JsonBufferView<'a> {
     storage: Box<dyn JsonBufferViewing + 'a>,
     gate: &'a GateState,
-    buffer: Entity,
     session: Entity,
 }
 
@@ -412,15 +411,13 @@ pub trait JsonBufferWorldAccess {
     /// Call this to get read-only access to any buffer whose message type is
     /// serializable and deserializable.
     ///
-    /// Pass in a callback that will receive a [`JsonBufferView`] alongside a
-    /// shared borrow of the [`World`]. Due to technical reasons this function
-    /// needs to be called on a `&mut World`, but you can still view the world
-    /// from inside the callback using the second argument.
-    fn json_buffer_view<U>(
-        &mut self,
+    /// For technical reasons this requires direct [`World`] access, but you can
+    /// do other read-only queries on the world while holding onto the
+    /// [`JsonBufferView`].
+    fn json_buffer_view(
+        &self,
         key: &JsonBufferKey,
-        f: impl FnOnce(JsonBufferView, &World) -> U,
-    ) -> Result<U, BufferError>;
+    ) -> Result<JsonBufferView<'_>, BufferError>;
 
     /// Call this to get mutable access to any buffer whose message type is
     /// serializable and deserializable.
@@ -435,16 +432,11 @@ pub trait JsonBufferWorldAccess {
 }
 
 impl JsonBufferWorldAccess for World {
-    fn json_buffer_view<U>(
-        &mut self,
+    fn json_buffer_view(
+        &self,
         key: &JsonBufferKey,
-        f: impl FnOnce(JsonBufferView, &World) -> U,
-    ) -> Result<U, BufferError> {
-        let interface = key.interface;
-        let mut state = interface.create_json_buffer_access_state(self);
-        let access = state.get_json_buffer_access(self);
-        let buffer_view = access.as_json_buffer_view(key)?;
-        Ok(f(buffer_view, &self))
+    ) -> Result<JsonBufferView<'_>, BufferError> {
+        key.interface.create_json_buffer_view(key, self)
     }
 
     fn json_buffer_mut<U>(
@@ -695,10 +687,11 @@ trait JsonBufferAccessInterface {
         session: Entity,
     ) -> Result<JsonMessage, OperationError>;
 
-    fn create_json_buffer_access_state(
+    fn create_json_buffer_view<'a>(
         &self,
-        world: &mut World,
-    ) -> Box<dyn JsonBufferAccessState>;
+        key: &JsonBufferKey,
+        world: &'a World,
+    ) -> Result<JsonBufferView<'a>, BufferError>;
 
     fn create_json_buffer_access_mut_state(
         &self,
@@ -764,11 +757,19 @@ impl<T: 'static + Send + Sync + Serialize + DeserializeOwned> JsonBufferAccessIn
         serde_json::to_value(value).or_broken()
     }
 
-    fn create_json_buffer_access_state(
+    fn create_json_buffer_view<'a>(
         &self,
-        world: &mut World,
-    ) -> Box<dyn JsonBufferAccessState> {
-        Box::new(SystemState::<BufferAccess<T>>::new(world))
+        key: &JsonBufferKey,
+        world: &'a World,
+    ) -> Result<JsonBufferView<'a>, BufferError> {
+        let buffer_ref = world.get_entity(key.buffer).ok_or(BufferError::BufferMissing)?;
+        let storage = buffer_ref.get::<BufferStorage<T>>().ok_or(BufferError::BufferMissing)?;
+        let gate = buffer_ref.get::<GateState>().ok_or(BufferError::BufferMissing)?;
+        Ok(JsonBufferView {
+            storage: Box::new(storage),
+            gate,
+            session: key.session,
+        })
     }
 
     fn create_json_buffer_access_mut_state(
@@ -779,19 +780,6 @@ impl<T: 'static + Send + Sync + Serialize + DeserializeOwned> JsonBufferAccessIn
     }
 }
 
-trait JsonBufferAccessState {
-    fn get_json_buffer_access<'s, 'w: 's>(&'s mut self, world: &'w World) -> Box<dyn JsonBufferAccess<'w, 's> + 's>;
-}
-
-impl<T> JsonBufferAccessState for SystemState<BufferAccess<'static, 'static, T>>
-where
-    T: 'static + Send + Sync + Serialize + DeserializeOwned,
-{
-    fn get_json_buffer_access<'s, 'w: 's>(&'s mut self, world: &'w World) -> Box<dyn JsonBufferAccess<'w, 's> + 's> {
-        Box::new(self.get(world))
-    }
-}
-
 trait JsonBufferAccessMutState {
     fn get_json_buffer_access_mut<'s, 'w: 's>(&'s mut self, world: &'w mut World) -> Box<dyn JsonBufferAccessMut<'w, 's> + 's>;
 }
@@ -805,26 +793,6 @@ where
     }
 }
 
-trait JsonBufferAccess<'w, 's> {
-    fn as_json_buffer_view<'a>(&'a self, key: &JsonBufferKey) -> Result<JsonBufferView<'a>, BufferError>;
-}
-
-impl<'w, 's, T> JsonBufferAccess<'w, 's> for BufferAccess<'w, 's, T>
-where
-    T: 'static + Send + Sync + Serialize + DeserializeOwned,
-{
-    fn as_json_buffer_view<'a>(&'a self, key: &JsonBufferKey) -> Result<JsonBufferView<'a>, BufferError> {
-        let BufferAccess { query } = self;
-        let (storage, gate) = query.get(key.buffer).map_err(|_| BufferError::BufferMissing)?;
-        Ok(JsonBufferView {
-            storage: Box::new(storage),
-            gate,
-            buffer: key.buffer,
-            session: key.session,
-        })
-    }
-}
-
 trait JsonBufferAccessMut<'w, 's> {
     fn as_json_buffer_mut<'a>(&'a mut self, key: &JsonBufferKey) -> Result<JsonBufferMut<'w, 's ,'a>, BufferError>;
 }
@@ -1022,9 +990,7 @@ mod tests {
         In(key): In<JsonBufferKey>,
         world: &mut World,
     ) -> usize {
-        world.json_buffer_view(&key, |access, _| {
-            access.len()
-        }).unwrap()
+        world.json_buffer_view(&key).unwrap().len()
     }
 
     #[test]