From 60fae25419294d9651b297072ba3928938d4e3a7 Mon Sep 17 00:00:00 2001 From: ModulatingForce <116608425+modulatingforce@users.noreply.github.com> Date: Wed, 27 Mar 2024 18:29:14 -0400 Subject: [PATCH] comments --- src/core/botmodules.rs | 170 +++++++++++++++++++++++++++++++---------- 1 file changed, 130 insertions(+), 40 deletions(-) diff --git a/src/core/botmodules.rs b/src/core/botmodules.rs index c113af5..f1997ad 100644 --- a/src/core/botmodules.rs +++ b/src/core/botmodules.rs @@ -631,8 +631,91 @@ pub struct Routine { impl Routine { + + + pub async fn validate_attr(routine_attr : &Vec) + -> Result + // [ ] => 03.27 - WIP + { + + /* + + GENERAL LOGIC : + [ ] 1. Define RoutineAttr in a broad level that are known to be implented or are work in progress + [ ] 2. Built in Logic will check these vectors, and return if Not Implemented + [ ] 3. If Implemented , then there are additional internal validation based on combination done later + + */ + + + // [x] 1. Define RoutineAttr in a broad level that are known to be implented or are work in progress + + // adjust the below for those that are work in progress or that are implemented + // - This will allow other functions to validate that it is implemented + + // WORK IN PROGRESS VECTOR - Vec<$RoutineAttr> + + let wip_attr:Vec<&RoutineAttr> = vec![ + &RoutineAttr::RunOnce + ]; + + let implemented_attr:Vec<&RoutineAttr> = vec![ + ]; + + + // [x] 2. Built in Logic will check these vectors, and return if Not Implemented + + let mut unimplemented = routine_attr.iter().filter(|x| !wip_attr.contains(x) && !implemented_attr.contains(x)); + + if unimplemented.next().is_some() { + + botlog::trace( + "[ERROR][Routine Feature NOT IMPLEMENTED]", + Some("Routine > Validate_attr()".to_string()), + None, + ); + + Log::flush(); + + return Err("NOT IMPLEMENTED".to_string()); + } + + + + + + // [ ] 3. If Implemented , then there are additional internal validation based on combination done later + + if routine_attr.contains(&RoutineAttr::RunOnce) { + return Ok("Valid & Implemented Setup".to_string()) + } + + + + + + + botlog::trace( + "[ERROR][Routine Feature NOT IMPLEMENTED]", + Some("Routine > Validate_attr()".to_string()), + None, + ); + + Log::flush(); + + return Err("NOT IMPLEMENTED".to_string()) + + } + + pub async fn validate_self_attr(self) + -> Result + // [x] => 03.27 - COMPLETED + { + Routine::validate_attr(&self.routine_attr).await + } + // Constructor - pub fn from( + pub async fn from( name : String , module : BotModule , channel : Channel, @@ -642,35 +725,34 @@ impl Routine { ) -> Result< Arc>, String - > { + > + // [x] => 03.27 - COMPLETED + { - // [ ] Validation is made against parent_params - // to ensure those params don't conflict - // conlicts would throw an error - - if routine_attr.contains(&RoutineAttr::RunOnce) { - return Ok(Arc::new(RwLock::new(Routine { - name , - module , - channel , - exec_body , - parent_params , - join_handle : None , - start_time : None , - complete_iterations : 0 , - remaining_iterations : None , - routine_attr : routine_attr - }))) ; - } + Routine::validate_attr(&routine_attr).await?; + + return Ok(Arc::new(RwLock::new(Routine { + name , + module , + channel , + exec_body , + parent_params , + join_handle : None , + start_time : None , + complete_iterations : 0 , + remaining_iterations : None , + routine_attr : routine_attr + }))) ; - Err("NOT IMPLEMENTED".to_string()) } pub fn change_channel( &self, _channel : Channel - ) -> Result { + ) -> Result + // [ ] => 03.27 - WIP - NOT IMPLEMENTED + { // [ ] Think Ideally it should try to // change the target channel of the // internal process too if possible? @@ -682,6 +764,7 @@ impl Routine { trg_routine_ar : Arc> // ) -> Result ) -> Result>,String> + // [ ] => 03.27 - WIP { // [ ] Asyncio Spawn likely around here @@ -703,28 +786,30 @@ impl Routine { // Use the following to stop the function from going any further if not implemented - if !trg_routine_ar.read().await.routine_attr.contains(&RoutineAttr::RunOnce) { + + Routine::validate_attr(&trg_routine_ar.read().await.routine_attr).await?; + // if !trg_routine_ar.read().await.routine_attr.contains(&RoutineAttr::RunOnce) { - botlog::trace( - format!( - "[ERROR][Routine Feature NOT IMPLEMENTED] {} in {}", - trg_routine_ar.read().await.name, - trg_routine_ar.read().await.channel.0 - ) - .as_str(), - Some(format!( - "Routine > start() > (In Tokio Spawn) > {:?}", - trg_routine_ar.read().await.module - )), - Some(&trg_routine_ar.read().await.parent_params.msg), - ); + // botlog::trace( + // format!( + // "[ERROR][Routine Feature NOT IMPLEMENTED] {} in {}", + // trg_routine_ar.read().await.name, + // trg_routine_ar.read().await.channel.0 + // ) + // .as_str(), + // Some(format!( + // "Routine > start() > (In Tokio Spawn) > {:?}", + // trg_routine_ar.read().await.module + // )), + // Some(&trg_routine_ar.read().await.parent_params.msg), + // ); - Log::flush(); + // Log::flush(); - return Err("NOT IMPLEMENTED".to_string()) + // return Err("NOT IMPLEMENTED".to_string()) - } + // } let trg_routine_arout = Arc::clone(&trg_routine_ar); @@ -773,6 +858,7 @@ impl Routine { } // End of Loop Validation + // These generally may include routine_attr related checks if trg_routine_ar.read().await.routine_attr.contains(&RoutineAttr::RunOnce) { if trg_routine_ar.read().await.complete_iterations > 0 { break; } @@ -824,7 +910,8 @@ impl Routine { } - async fn loopbody(&self) + async fn loopbody(&self) + // [x] => 03.27 - COMPLETED { botlog::trace( "loopbody() started", @@ -842,6 +929,7 @@ impl Routine { } pub async fn stop(&self) -> Result + // [ ] => 03.27 - WIP - NOT IMPLEMENTED { @@ -871,6 +959,7 @@ impl Routine { &self, _force : bool ) -> Result + // [ ] => 03.27 - WIP - NOT IMPLEMENTED { // force flag aborts the routine immediately (like cancel()) @@ -897,6 +986,7 @@ impl Routine { } pub async fn cancel(&self) -> Result + // [ ] => 03.27 - WIP - NOT IMPLEMENTED { // [ ] Likely calls abort()