/home/gh-runner/action-runner3/_work/feoxdb/feoxdb/src/error.rs

Source
use std::io;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum FeoxError {
    #[error(
        "Invalid key size: key must be 1-{} bytes",
        crate::constants::MAX_KEY_SIZE
    )]
    InvalidKeySize,

    #[error(
        "Invalid value size: value must be 1-{} bytes",
        crate::constants::MAX_VALUE_SIZE
    )]
    InvalidValueSize,

    #[error("Key not found")]
    KeyNotFound,

    #[error("Database is full")]
    DatabaseFull,

    #[error("Out of memory")]
    OutOfMemory,

    #[error("Timestamp is older than existing record")]
    OlderTimestamp,

    #[error("Invalid numeric value")]
    InvalidNumericValue,

    #[error("Numeric overflow")]
    NumericOverflow,

    #[error("Invalid range: start key must be <= end key")]
    InvalidRange,

    #[error("Multi-tenant mode is disabled")]
    MultiTenantDisabled,

    #[error("No device configured")]
    NoDevice,

    #[error("Invalid metadata")]
    InvalidMetadata,

    #[error("Corrupted record")]
    CorruptedRecord,

    #[error("Invalid record")]
    InvalidRecord,

    #[error("Invalid device")]
    InvalidDevice,

    #[error("Invalid operation")]
    InvalidOperation,

    #[error("IO error: {0}")]
    IoError(#[from] io::Error),

    #[error("System error: {0}")]
    SystemError(i32),

    #[error("JSON patch error: {0}")]
    JsonPatchError(String),

    #[error("Allocation failed")]
    AllocationFailed,

    #[error("Lock poisoned")]
    LockPoisoned,

    #[error("Channel closed")]
    ChannelClosed,

    #[error("Channel error")]
    ChannelError,

    #[error("System shutting down")]
    ShuttingDown,

    #[error("Operation timed out")]
    Timeout,

    #[error("Not implemented")]
    NotImplemented,

    #[error("Unsupported on this platform")]
    Unsupported,

    #[error("Size mismatch: expected {expected} bytes, got {actual} bytes")]
    SizeMismatch { expected: usize, actual: usize },

    #[error("Invalid argument")]
    InvalidArgument,

    #[error("Out of space")]
    OutOfSpace,

    #[error("Corrupted data")]
    CorruptedData,

    #[error("Duplicate key")]
    DuplicateKey,

    #[error("TTL feature is not enabled")]
    TtlNotEnabled,
}

pub type Result<T> = std::result::Result<T, FeoxError>;

impl From<i32> for FeoxError {
    fn from(errno: i32) -> Self {
        match errno {
            2 => FeoxError::KeyNotFound,
            12 => FeoxError::OutOfMemory,
            17 => FeoxError::OlderTimestamp,
            22 => FeoxError::InvalidKeySize,
            28 => FeoxError::DatabaseFull,
            75 => FeoxError::NumericOverflow,
            90 => FeoxError::SizeMismatch {
                expected: 0,
                actual: 0,
            },
            _ => FeoxError::SystemError(errno),
        }
    }
}

impl FeoxError {
    pub fn errno(&self) -> i32 {
        match self {
            FeoxError::InvalidKeySize | FeoxError::InvalidValueSize => crate::constants::EINVAL,
            FeoxError::KeyNotFound => crate::constants::ENOENT,
            FeoxError::DatabaseFull => crate::constants::ENOSPC,
            FeoxError::OutOfMemory | FeoxError::AllocationFailed => crate::constants::ENOMEM,
            FeoxError::OlderTimestamp => crate::constants::EEXIST,
            FeoxError::NumericOverflow => crate::constants::EOVERFLOW,
            FeoxError::InvalidRange => crate::constants::EINVAL,
            FeoxError::MultiTenantDisabled => crate::constants::ENODEV,
            FeoxError::NoDevice => crate::constants::ENODEV,
            FeoxError::InvalidMetadata | FeoxError::CorruptedRecord => crate::constants::EIO,
            FeoxError::IoError(_) => crate::constants::EIO,
            FeoxError::SystemError(e) => *e,
            FeoxError::Timeout => crate::constants::EAGAIN,
            FeoxError::SizeMismatch { .. } => crate::constants::EMSGSIZE,
            _ => crate::constants::EIO,
        }
    }
}

Line	Count	Source
1		use std::io;
2		use thiserror::Error;
3
4		#[derive(Error, Debug)]
5		pub enum FeoxError {
6		#[error(
7		"Invalid key size: key must be 1-{} bytes",
8		crate::constants::MAX_KEY_SIZE
9		)]
10		InvalidKeySize,
11
12		#[error(
13		"Invalid value size: value must be 1-{} bytes",
14		crate::constants::MAX_VALUE_SIZE
15		)]
16		InvalidValueSize,
17
18		#[error("Key not found")]
19		KeyNotFound,
20
21		#[error("Database is full")]
22		DatabaseFull,
23
24		#[error("Out of memory")]
25		OutOfMemory,
26
27		#[error("Timestamp is older than existing record")]
28		OlderTimestamp,
29
30		#[error("Invalid numeric value")]
31		InvalidNumericValue,
32
33		#[error("Numeric overflow")]
34		NumericOverflow,
35
36		#[error("Invalid range: start key must be <= end key")]
37		InvalidRange,
38
39		#[error("Multi-tenant mode is disabled")]
40		MultiTenantDisabled,
41
42		#[error("No device configured")]
43		NoDevice,
44
45		#[error("Invalid metadata")]
46		InvalidMetadata,
47
48		#[error("Corrupted record")]
49		CorruptedRecord,
50
51		#[error("Invalid record")]
52		InvalidRecord,
53
54		#[error("Invalid device")]
55		InvalidDevice,
56
57		#[error("Invalid operation")]
58		InvalidOperation,
59
60		#[error("IO error: {0}")]
61		IoError(#[from] io::Error),
62
63		#[error("System error: {0}")]
64		SystemError(i32),
65
66		#[error("JSON patch error: {0}")]
67		JsonPatchError(String),
68
69		#[error("Allocation failed")]
70		AllocationFailed,
71
72		#[error("Lock poisoned")]
73		LockPoisoned,
74
75		#[error("Channel closed")]
76		ChannelClosed,
77
78		#[error("Channel error")]
79		ChannelError,
80
81		#[error("System shutting down")]
82		ShuttingDown,
83
84		#[error("Operation timed out")]
85		Timeout,
86
87		#[error("Not implemented")]
88		NotImplemented,
89
90		#[error("Unsupported on this platform")]
91		Unsupported,
92
93		#[error("Size mismatch: expected {expected} bytes, got {actual} bytes")]
94		SizeMismatch { expected: usize, actual: usize },
95
96		#[error("Invalid argument")]
97		InvalidArgument,
98
99		#[error("Out of space")]
100		OutOfSpace,
101
102		#[error("Corrupted data")]
103		CorruptedData,
104
105		#[error("Duplicate key")]
106		DuplicateKey,
107
108		#[error("TTL feature is not enabled")]
109		TtlNotEnabled,
110		}
111
112		pub type Result<T> = std::result::Result<T, FeoxError>;
113
114		impl From<i32> for FeoxError {
115	0	fn from(errno: i32) -> Self {
116	0	match errno {
117	0	2 => FeoxError::KeyNotFound,
118	0	12 => FeoxError::OutOfMemory,
119	0	17 => FeoxError::OlderTimestamp,
120	0	22 => FeoxError::InvalidKeySize,
121	0	28 => FeoxError::DatabaseFull,
122	0	75 => FeoxError::NumericOverflow,
123	0	90 => FeoxError::SizeMismatch {
124	0	expected: 0,
125	0	actual: 0,
126	0	},
127	0	_ => FeoxError::SystemError(errno),
128		}
129	0	}
130		}
131
132		impl FeoxError {
133	0	pub fn errno(&self) -> i32 {
134	0	match self {
135	0	FeoxError::InvalidKeySize \| FeoxError::InvalidValueSize => crate::constants::EINVAL,
136	0	FeoxError::KeyNotFound => crate::constants::ENOENT,
137	0	FeoxError::DatabaseFull => crate::constants::ENOSPC,
138	0	FeoxError::OutOfMemory \| FeoxError::AllocationFailed => crate::constants::ENOMEM,
139	0	FeoxError::OlderTimestamp => crate::constants::EEXIST,
140	0	FeoxError::NumericOverflow => crate::constants::EOVERFLOW,
141	0	FeoxError::InvalidRange => crate::constants::EINVAL,
142	0	FeoxError::MultiTenantDisabled => crate::constants::ENODEV,
143	0	FeoxError::NoDevice => crate::constants::ENODEV,
144	0	FeoxError::InvalidMetadata \| FeoxError::CorruptedRecord => crate::constants::EIO,
145	0	FeoxError::IoError(_) => crate::constants::EIO,
146	0	FeoxError::SystemError(e) => *e,
147	0	FeoxError::Timeout => crate::constants::EAGAIN,
148	0	FeoxError::SizeMismatch { .. } => crate::constants::EMSGSIZE,
149	0	_ => crate::constants::EIO,
150		}
151	0	}
152		}

Coverage Report

Created: 2025-09-19 09:35