Author: NikolaRHristov

Cargo.toml

@@ -4,7 +4,7 @@ toml = { workspace = true }
 
 
 [dependencies]
-async_trait = { workspace = true }
+async-trait = { workspace = true }
 config = { workspace = true }
 dashmap = { workspace = true }
 env_logger = { workspace = true }
@@ -16,10 +16,11 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
-tokio_console = { workspace = true, optional = true }
-tokio_tungstenite = { workspace = true }
+tokio-console = { workspace = true, optional = true }
+tokio-tungstenite = { workspace = true }
 unbug = { workspace = true }
-crossbeam_deque = { workspace = true }
+crossbeam-deque = { workspace = true }
+num_cpus = { workspace = true }
 
 [[example]]
 name = "Sequence"

Source/Queue/StealingQueue.rs

@@ -4,7 +4,7 @@
 use crossbeam_deque::{Injector, Stealer, Worker};
 use rand::seq::SliceRandom;
 
-use crate::Task::{Priority, Task};
+use crate::Task::{Priority::Priority, Task::Task};
 
 /// A container for a set of queues for a single priority level.
 struct PriorityQueueSet {
@@ -84,7 +84,7 @@ impl StealingQueue {
 		// Try stealing from peers for this priority set. We shuffle the indices
 		// to ensure fairness and avoid contention hotspots.
 		let mut ShuffledIndex:Vec<usize> = (0..Set.Stealer.len()).collect();
-		ShuffledIndex.shuffle(&mut rand::thread_rng());
+		ShuffledIndex.shuffle(&mut rand::rng());
 
 		for Index in ShuffledIndex {
 			if Index == WorkerId {

Source/Scheduler/Scheduler.rs

@@ -15,9 +15,9 @@ use tokio::task::JoinHandle;
 /// queue, and task execution lifecycle.
 use super::Worker::Worker;
 use crate::{
-	Queue::StealingQueue,
+	Queue::StealingQueue::StealingQueue,
 	Scheduler::SchedulerBuilder::Concurrency,
-	Task::{Priority, Task},
+	Task::{Priority::Priority, Task::Task},
 };
 
 /// Manages a pool of worker threads and a work-stealing queue to execute tasks

Source/Scheduler/SchedulerBuilder.rs

@@ -5,7 +5,7 @@ use std::collections::HashMap;
 
 use log::warn;
 
-use super::Scheduler;
+use super::Scheduler::Scheduler;
 
 /// An enum to define concurrency limits for named queues.
 #[derive(Debug, Clone, Copy)]
@@ -33,7 +33,7 @@ impl SchedulerBuilder {
 	/// By default, the worker count is set to the number of logical CPUs on the
 	/// system, with a minimum of 2.
 	pub fn New() -> Self {
-		let DefaultWorkerCount = num_cpus::get().max(2).expect("");
+		let DefaultWorkerCount = num_cpus::get().max(2);
 		Self { WorkerCount:DefaultWorkerCount, QueueConfiguration:HashMap::new() }
 	}
 
@@ -45,7 +45,7 @@ impl SchedulerBuilder {
 	pub fn WithWorkerCount(mut self, WorkerCount:usize) -> Self {
 		if WorkerCount == 0 {
 			warn!("[SchedulerBuilder] Worker count of 0 is invalid. Defaulting to number of logical CPUs.");
-			self.WorkerCount = num_cpus::get().max(2).expect("");
+			self.WorkerCount = num_cpus::get().max(2);
 		} else {
 			self.WorkerCount = WorkerCount;
 		}

Source/Scheduler/Worker.rs

@@ -10,7 +10,7 @@ use tokio::time::{Duration, sleep};
 /// @description Defines the `Worker` struct, which represents a single
 /// execution thread in the scheduler's pool. This is an internal component of
 /// the scheduler.
-use crate::Queue::StealingQueue;
+use crate::Queue::StealingQueue::StealingQueue;
 
 /// Represents a single worker thread that continuously polls the work-stealing
 /// queue for tasks to execute.