Reorganizing delivery instructions

Signed-off-by: Michael X. Grey <grey@openrobotics.org>

Author: mxgrey

src/channel.rs

@@ -168,10 +168,10 @@ mod tests {
             assert!(promise.peek().is_available());
         }
 
-        let count = context.app.world.get::<RunCount>(hello.get()).unwrap().0;
+        let count = context.app.world.get::<RunCount>(hello.provider()).unwrap().0;
         assert_eq!(count, 25);
 
-        let count = context.app.world.get::<RunCount>(repeat.get()).unwrap().0;
+        let count = context.app.world.get::<RunCount>(repeat.provider()).unwrap().0;
         assert_eq!(count, 5);
     }
 }

src/operation.rs

@@ -16,7 +16,7 @@
 */
 
 use crate::{
-    RequestLabelId, Cancel, ManageInput, InspectInput, UnhandledErrors,
+    DeliveryLabelId, Cancel, ManageInput, InspectInput, UnhandledErrors,
     CancelFailure, Broken, ManageCancellation, ManageDisposal,
 };
 
@@ -260,7 +260,7 @@ pub(crate) struct Blocker {
     /// The session that is doing the blocking
     pub(crate) session: Entity,
     /// The label of the queue that is being blocked
-    pub(crate) label: Option<RequestLabelId>,
+    pub(crate) label: Option<DeliveryLabelId>,
     /// Function pointer to call when this is no longer blocking
     pub(crate) serve_next: fn(Blocker, &mut World, &mut OperationRoster),
 }

src/operation/operate_service.rs

@@ -45,7 +45,7 @@ impl<Request: 'static + Send + Sync> OperateService<Request> {
         target: Entity,
     ) -> Self {
         Self {
-            provider: provider.get(),
+            provider: provider.provider(),
             target,
             _ignore: Default::default(),
         }

src/request.rs

@@ -20,24 +20,13 @@ use crate::{
     ModifiersUnset, AddOperation, Noop, IntoAsyncMap,
 };
 
-use bevy::{
-    prelude::Commands,
-    utils::define_label,
-};
+use bevy::prelude::Commands;
 
 use std::future::Future;
 
 mod internal;
 pub use internal::{ApplyLabel, BuildLabel};
 
-define_label!(
-    /// A strongly-typed class of labels used to identify requests that have been
-    /// issued to a service.
-    RequestLabel,
-    /// Strongly-typed identifier for a [`RequestLabel`].
-    RequestLabelId,
-);
-
 pub trait RequestExt<'w, 's> {
     /// Call this on [`Commands`] to begin building a impulse chain by submitting
     /// a request to a provider.
@@ -130,97 +119,6 @@ async fn async_server<T: Future>(value: T) -> T::Output {
     value.await
 }
 
-/// By default when a service provider receives a new request with the same
-/// label as an earlier request, the earlier request will be cancelled,
-/// whether it is already being executed or whether it is sitting in a
-/// queue. If the earlier request was already delivered then the labeling
-/// has no effect.
-///
-/// To change the default behavior there are two modifiers you can apply to
-/// this label:
-/// - `.queue()` asks for the request to be queued up to run after all
-///   other requests with this same label have been fulfilled and not cancel
-///   any of them.
-/// - `.ensure()` asks for this request to not be cancelled even if another
-///   request comes in with the same label. The new request will instead be
-///   queued after this one.
-///
-/// You can choose to use either, both, or neither of these modifiers in
-/// whatever way fits your use case. No matter what modifiers you choose
-/// (or don't choose) the same service provider will never simultaneously
-/// execute its service for two requests with the same label value. To that
-/// extent, applying a label always guarantees mutual exclusivity between
-/// requests.
-///
-/// This mutual exclusivity can be useful if the service involves making
-/// modifications to the world which would conflict with each other when two
-/// related requests are being delivered at the same time.
-pub struct LabelBuilder<Q, E> {
-    label: RequestLabelId,
-    queue: bool,
-    ensure: bool,
-    _ignore: std::marker::PhantomData<(Q, E)>,
-}
-
-pub struct Chosen;
-
-impl LabelBuilder<(), ()> {
-    /// Begin building a label for a request. You do not need to call this
-    /// function explicitly. You can instead use `.queue()` or `.ensure()`
-    /// directly on a `RequestLabel` instance.
-    pub fn new(label: impl RequestLabel) -> LabelBuilder<(), ()> {
-        LabelBuilder {
-            label: label.as_label(),
-            queue: false,
-            ensure: false,
-            _ignore: Default::default()
-        }
-    }
-}
-
-impl<E> LabelBuilder<(), E> {
-    /// Queue this labeled request to be handled **after** all other requests
-    /// with the same label have been fulfilled. Do not automatically cancel
-    /// pending requests that have the same label.
-    ///
-    /// The default behavior, if you do **not** trigger this method, is for this
-    /// new labeled request to supplant all prior requests that share the same
-    /// label, sending them to the cancelled state (unless the prior request was
-    /// marked with [`ensure()`]).
-    ///
-    /// This modifer can only be applied to a labeled request because it does
-    /// not make sense for unlabeled requests.
-    pub fn queue(self) -> LabelBuilder<Chosen, E> {
-        LabelBuilder {
-            label: self.label,
-            queue: true,
-            ensure: self.ensure,
-            _ignore: Default::default(),
-        }
-    }
-}
-
-impl<Q> LabelBuilder<Q, ()> {
-    /// Ensure that this request is resolved even if another request with the
-    /// same label arrives.
-    ///
-    /// Ordinarily a new labeled request would supplant all earlier requests
-    /// with the same label, sending them into the cancelled state. But any
-    /// of those requests that are "ensured" will remain queued and finish
-    /// executing, one at a time.
-    ///
-    /// This modifier can only be applied to labeled requests because it does
-    /// not make sense for unlabeled requests.
-    pub fn ensure(self) -> LabelBuilder<Q, Chosen> {
-        LabelBuilder {
-            label: self.label,
-            queue: self.queue,
-            ensure: true,
-            _ignore: Default::default(),
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use crate::{*, testing::*};

src/request/internal.rs

@@ -16,7 +16,7 @@
 */
 
 use crate::{
-    LabelBuilder, DeliveryInstructions, RequestLabel, Chosen,
+    LabelBuilder, DeliveryInstructions, DeliveryLabel, Chosen,
 };
 
 use bevy::ecs::system::EntityCommands;
@@ -38,7 +38,7 @@ pub trait ApplyLabel {
     fn apply<'w, 's, 'a>(self, commands: &mut EntityCommands<'w, 's, 'a>);
 }
 
-impl<T: RequestLabel> ApplyLabel for T {
+impl<T: DeliveryLabel> ApplyLabel for T {
     fn apply<'w, 's, 'a>(self, commands: &mut EntityCommands<'w, 's, 'a>) {
         LabelBuilder::new(self).apply(commands)
     }
@@ -48,7 +48,7 @@ impl<Q, E> ApplyLabel for LabelBuilder<Q, E> {
     fn apply<'w, 's, 'a>(self, commands: &mut EntityCommands<'w, 's, 'a>) {
         commands.insert(DeliveryInstructions {
             label: self.label,
-            queue: self.queue,
+            preempt: self.queue,
             ensure: self.ensure,
         });
     }
@@ -61,7 +61,7 @@ pub trait BuildLabel {
     fn ensure(self) -> LabelBuilder<(), Chosen>;
 }
 
-impl<T: RequestLabel> BuildLabel for T {
+impl<T: DeliveryLabel> BuildLabel for T {
     /// Specify that the labeled request should queue itself instead of
     /// cancelling prior requests with the same label.
     fn queue(self) -> LabelBuilder<Chosen, ()> {