Finish workflow spawning implementation

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

Author: mxgrey

src/operation/scope.rs

@@ -22,12 +22,13 @@ use crate::{
     Cancellation, Unreachability, InspectDisposals, execute_operation,
     BufferSettings, Buffer, CancellableBundle, OperationRoster, ManageCancellation,
     OperationError, OperationCancel, Cancel, UnhandledErrors, check_reachability,
-    Blocker, Stream, StreamTargetStorage, StreamRequest,
+    Blocker, Stream, StreamTargetStorage, StreamRequest, AddOperation,
+    ScopeSettings,
 };
 
 use backtrace::Backtrace;
 
-use bevy::prelude::{Component, Entity, World};
+use bevy::prelude::{Component, Entity, World, Commands};
 
 use smallvec::SmallVec;
 
@@ -46,6 +47,7 @@ impl ParentSession {
     }
 }
 
+#[derive(Clone)]
 pub(crate) struct OperateScope<Request, Response, Streams> {
     /// The first node that is inside of the scope
     enter_scope: Entity,
@@ -64,13 +66,12 @@ pub(crate) struct OperateScope<Request, Response, Streams> {
 }
 
 impl<Request, Response, Streams> OperateScope<Request, Response, Streams> {
-    pub(crate) fn new(
-        enter_scope: Entity,
-        terminal: Entity,
-        exit_scope: Option<Entity>,
-        finish_cancel: Entity,
-    ) -> Self {
-        Self { enter_scope, terminal, exit_scope, finish_cancel, _ignore: Default::default() }
+    pub(crate) fn terminal(&self) -> Entity {
+        self.terminal
+    }
+
+    pub(crate) fn enter_scope(&self) -> Entity {
+        self.enter_scope
     }
 }
 
@@ -139,7 +140,7 @@ impl TerminalStorage {
     }
 }
 
-impl<Request, Streams, Response> Operation for OperateScope<Request, Streams, Response>
+impl<Request, Response, Streams> Operation for OperateScope<Request, Response, Streams>
 where
     Request: 'static + Send + Sync,
     Streams: StreamPack,
@@ -294,12 +295,37 @@ where
     Ok(())
 }
 
-impl<Request, Streams, Response> OperateScope<Request, Streams, Response>
+impl<Request, Response, Streams> OperateScope<Request, Response, Streams>
 where
     Request: 'static + Send + Sync,
-    Streams: StreamPack,
     Response: 'static + Send + Sync,
+    Streams: StreamPack,
 {
+    pub(crate) fn new(
+        scope_id: Entity,
+        exit_scope: Option<Entity>,
+        settings: ScopeSettings,
+        commands: &mut Commands,
+    ) -> Self {
+        let enter_scope = commands.spawn(()).id();
+        let terminal = commands.spawn(()).id();
+        let finish_cancel = commands.spawn(()).id();
+        commands.add(AddOperation::new(
+            finish_cancel,
+            FinishCancel { from_scope: scope_id },
+        ));
+
+        let scope = OperateScope {
+            enter_scope,
+            terminal,
+            exit_scope,
+            finish_cancel,
+            _ignore: Default::default(),
+        };
+
+        scope
+    }
+
     fn receive_cancel(
         OperationCancel {
             cancel: Cancel { source: _origin, target: source, session, cancellation },
@@ -810,7 +836,6 @@ pub(crate) struct FinishCancel {
 
 impl Operation for FinishCancel {
     fn setup(self, OperationSetup { source, world }: OperationSetup) -> OperationResult {
-        // world.get_entity_mut(entity)
         world.entity_mut(source).insert((
             CancelFromScope(self.from_scope),
             InputBundle::<()>::new(),

src/service.rs

@@ -195,6 +195,7 @@ impl<Request, Response, Streams> Service<Request, Response, Streams> {
     /// following:
     /// - App::add_*_service
     /// - Commands::spawn_*_service
+    /// - Commands::spawn_workflow
     /// - ServiceDiscovery::iter()
     fn new(entity: Entity) -> Self {
         Self { entity, _ignore: Default::default() }

src/service/workflow.rs

@@ -20,7 +20,7 @@ use crate::{
     OrBroken, Input, ManageInput, DeliveryInstructions, ParentSession,
     OperationError, Delivery, DeliveryOrder, DeliveryUpdate, Blocker,
     OperationRoster, Disposal, Cancellation, Cancel, Deliver, SingleTargetStorage,
-    ExitTargetStorage, ExitTarget,
+    ExitTargetStorage, ExitTarget, Service,
     begin_scope, dispose_for_despawned_service, insert_new_order, emit_disposal,
     pop_next_delivery,
 };
@@ -34,10 +34,16 @@ struct WorkflowStorage {
     scope: Entity,
 }
 
-struct WorkflowService<Request, Response, Streams> {
+pub(crate) struct WorkflowService<Request, Response, Streams> {
     _ignore: std::marker::PhantomData<(Request, Response, Streams)>,
 }
 
+impl<Request, Response, Streams> WorkflowService<Request, Response, Streams> {
+    pub(crate) fn cast(scope_id: Entity) -> Service<Request, Response, Streams> {
+        Service { entity: scope_id, _ignore: Default::default() }
+    }
+}
+
 impl<Request, Response, Streams> ServiceTrait for WorkflowService<Request, Response, Streams>
 where
     Request: 'static + Send + Sync,

src/workflow.rs

@@ -22,7 +22,7 @@ use bevy::{
 
 use crate::{
     Service, InputSlot, Output, StreamPack, AddOperation, OperateScope,
-    Terminate,
+    Terminate, WorkflowService,
 };
 
 /// Trait to allow workflows to be spawned from a [`Commands`] or a [`World`].
@@ -138,7 +138,7 @@ impl WorkflowSettings {
 
     /// Transform the settings to be uninterruptible
     pub fn uninterruptible(mut self) -> Self {
-        self.scope.uninterruptible = true;
+        self.scope.set_uninterruptible(true);
         self
     }
 }
@@ -196,6 +196,7 @@ impl ScopeSettings {
     }
 }
 
+
 impl<'w, 's> SpawnWorkflow for Commands<'w, 's> {
     fn spawn_workflow<Request, Response, Streams>(
         &mut self,
@@ -208,13 +209,10 @@ impl<'w, 's> SpawnWorkflow for Commands<'w, 's> {
         Streams: StreamPack,
     {
         let scope_id = self.spawn(()).id();
-        let enter_scope = self.spawn(()).id();
-        let terminal = self.spawn(()).id();
-        self.add(AddOperation::new(
-            scope_id,
-            OperateScope::new(enter_scope, terminal, None, self.spawn(()).id()),
-        ));
-        self.add(AddOperation::new(terminal, Terminate::new()));
+        let scope = OperateScope::<Request, Response, Streams>::new(
+            scope_id, None, settings.scope, self,
+        );
+        self.add(AddOperation::new(scope.terminal(), Terminate::<Response>::new()));
 
         let (
             stream_storage,
@@ -223,13 +221,15 @@ impl<'w, 's> SpawnWorkflow for Commands<'w, 's> {
         self.entity(scope_id).insert(stream_storage);
 
         let scope = Scope {
-            input: Output::new(scope_id, enter_scope),
-            terminate: InputSlot::new(scope_id, terminal),
+            input: Output::new(scope_id, scope.enter_scope()),
+            terminate: InputSlot::new(scope_id, scope.terminal()),
             streams,
         };
 
-        let builder = Builder { scope: scope_id, commands: self };
+        let mut builder = Builder { scope: scope_id, commands: self };
         build(scope, &mut builder);
+
+        WorkflowService::<Request, Response, Streams>::cast(scope_id)
     }
 }