micro_swarm 0.2.0

Swarm orchestration and coordination for micro-neural networks
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

//! Error types for the swarm system

use alloc::string::String;
use core::fmt;

/// Swarm error types
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SwarmError {
    /// Agent-related errors
    Agent(String),
    /// Task scheduling errors
    Scheduler(String),
    /// Memory management errors
    Memory(String),
    /// Communication channel errors
    Channel(String),
    /// Configuration errors
    Configuration(String),
    /// Resource exhaustion
    ResourceExhausted(String),
    /// Network/coordination errors
    Network(String),
    /// Timeout errors
    Timeout(String),
    /// Invalid state
    InvalidState(String),
    /// Not found errors
    NotFound(String),
}

impl fmt::Display for SwarmError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            SwarmError::Agent(msg) => write!(f, "Agent error: {}", msg),
            SwarmError::Scheduler(msg) => write!(f, "Scheduler error: {}", msg),
            SwarmError::Memory(msg) => write!(f, "Memory error: {}", msg),
            SwarmError::Channel(msg) => write!(f, "Channel error: {}", msg),
            SwarmError::Configuration(msg) => write!(f, "Configuration error: {}", msg),
            SwarmError::ResourceExhausted(msg) => write!(f, "Resource exhausted: {}", msg),
            SwarmError::Network(msg) => write!(f, "Network error: {}", msg),
            SwarmError::Timeout(msg) => write!(f, "Timeout: {}", msg),
            SwarmError::InvalidState(msg) => write!(f, "Invalid state: {}", msg),
            SwarmError::NotFound(msg) => write!(f, "Not found: {}", msg),
        }
    }
}

impl SwarmError {
    /// Create an agent error
    pub fn agent<S: Into<String>>(msg: S) -> Self {
        Self::Agent(msg.into())
    }
    
    /// Create a scheduler error
    pub fn scheduler<S: Into<String>>(msg: S) -> Self {
        Self::Scheduler(msg.into())
    }
    
    /// Create a memory error
    pub fn memory<S: Into<String>>(msg: S) -> Self {
        Self::Memory(msg.into())
    }
    
    /// Create a channel error
    pub fn channel<S: Into<String>>(msg: S) -> Self {
        Self::Channel(msg.into())
    }
    
    /// Create a configuration error
    pub fn config<S: Into<String>>(msg: S) -> Self {
        Self::Configuration(msg.into())
    }
    
    /// Create a resource exhausted error
    pub fn resource_exhausted<S: Into<String>>(msg: S) -> Self {
        Self::ResourceExhausted(msg.into())
    }
    
    /// Create a network error
    pub fn network<S: Into<String>>(msg: S) -> Self {
        Self::Network(msg.into())
    }
    
    /// Create a timeout error
    pub fn timeout<S: Into<String>>(msg: S) -> Self {
        Self::Timeout(msg.into())
    }
    
    /// Create an invalid state error
    pub fn invalid_state<S: Into<String>>(msg: S) -> Self {
        Self::InvalidState(msg.into())
    }
    
    /// Create a not found error
    pub fn not_found<S: Into<String>>(msg: S) -> Self {
        Self::NotFound(msg.into())
    }
}