Support for dynamic dictionaries of buffers

src/buffer.rs

@@ -24,16 +24,24 @@ use bevy_ecs::{
 
 use std::{ops::RangeBounds, sync::Arc};
 
+use thiserror::Error as ThisError;
+
 use crate::{
     Builder, Chain, Gate, GateState, InputSlot, NotifyBufferUpdate, OnNewBufferValue, UnusedTarget,
 };
 
+mod any_buffer;
+pub use any_buffer::*;
+
 mod buffer_access_lifecycle;
 pub(crate) use buffer_access_lifecycle::*;
 
 mod buffer_key_builder;
 pub(crate) use buffer_key_builder::*;
 
+mod buffer_map;
+pub use buffer_map::*;
+
 mod buffer_storage;
 pub(crate) use buffer_storage::*;
 
@@ -46,6 +54,11 @@ pub use bufferable::*;
 mod manage_buffer;
 pub use manage_buffer::*;
 
+#[cfg(feature = "diagram")]
+mod json_buffer;
+#[cfg(feature = "diagram")]
+pub use json_buffer::*;
+
 /// A buffer is a special type of node within a workflow that is able to store
 /// and release data. When a session is finished, the buffered data from the
 /// session will be automatically cleared.
@@ -89,6 +102,15 @@ impl<T> Buffer<T> {
     }
 }
 
+impl<T> Clone for Buffer<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T> Copy for Buffer<T> {}
+
+#[derive(Clone, Copy)]
 pub struct CloneFromBuffer<T: Clone> {
     pub(crate) scope: Entity,
     pub(crate) source: Entity,
@@ -157,22 +179,6 @@ impl Default for RetentionPolicy {
     }
 }
 
-impl<T> Clone for Buffer<T> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<T> Copy for Buffer<T> {}
-
-impl<T: Clone> Clone for CloneFromBuffer<T> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<T: Clone> Copy for CloneFromBuffer<T> {}
-
 /// This key can unlock access to the contents of a buffer by passing it into
 /// [`BufferAccess`] or [`BufferAccessMut`].
 ///
@@ -424,7 +430,7 @@ where
         self.len() == 0
     }
 
-    /// Check whether the gate of this buffer is open or closed
+    /// Check whether the gate of this buffer is open or closed.
     pub fn gate(&self) -> Gate {
         self.gate
             .map
@@ -467,7 +473,7 @@ where
         self.storage.drain(self.session, range)
     }
 
-    /// Pull the oldest item from the buffer
+    /// Pull the oldest item from the buffer.
     pub fn pull(&mut self) -> Option<T> {
         self.modified = true;
         self.storage.pull(self.session)
@@ -500,7 +506,7 @@ where
     // continuous systems with BufferAccessMut from running at the same time no
     // matter what the buffer type is.
 
-    /// Tell the buffer [`Gate`] to open
+    /// Tell the buffer [`Gate`] to open.
     pub fn open_gate(&mut self) {
         if let Some(gate) = self.gate.map.get_mut(&self.session) {
             if *gate != Gate::Open {
@@ -510,7 +516,7 @@ where
         }
     }
 
-    /// Tell the buffer [`Gate`] to close
+    /// Tell the buffer [`Gate`] to close.
     pub fn close_gate(&mut self) {
         if let Some(gate) = self.gate.map.get_mut(&self.session) {
             *gate = Gate::Closed;
@@ -519,7 +525,7 @@ where
         }
     }
 
-    /// Perform an action on the gate of the buffer
+    /// Perform an action on the gate of the buffer.
     pub fn gate_action(&mut self, action: Gate) {
         match action {
             Gate::Open => self.open_gate(),
@@ -569,6 +575,12 @@ where
     }
 }
 
+#[derive(ThisError, Debug, Clone)]
+pub enum BufferError {
+    #[error("The key was unable to identify a buffer")]
+    BufferMissing,
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{prelude::*, testing::*, Gate};