rvf 0.1.0

Rust implementation of the ValueFlows vocabulary for distributed economic networks
Documentation 
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

//! Error types for the ValueFlows implementation

use thiserror::Error;

/// Result type alias using the library's error type
pub type Result<T> = std::result::Result<T, Error>;

/// Error types for ValueFlows operations
#[derive(Error, Debug, Clone)]
pub enum Error {
    /// A required field is missing
    #[error("Missing required field: {0}")]
    MissingField(String),

    /// An invalid value was provided
    #[error("Invalid value for {field}: {message}")]
    InvalidValue { field: String, message: String },

    /// An entity was not found
    #[error("{entity_type} not found: {id}")]
    NotFound { entity_type: String, id: String },

    /// A duplicate entity already exists
    #[error("{entity_type} already exists: {id}")]
    Duplicate { entity_type: String, id: String },

    /// An invalid action for the given context
    #[error("Invalid action {action} for {context}")]
    InvalidAction { action: String, context: String },

    /// An invalid state transition
    #[error("Invalid state transition from {from} to {to}")]
    InvalidStateTransition { from: String, to: String },

    /// Insufficient resource quantity
    #[error("Insufficient quantity: required {required}, available {available}")]
    InsufficientQuantity { required: String, available: String },

    /// Unit mismatch in quantity operations
    #[error("Unit mismatch: cannot operate on {unit1} and {unit2}")]
    UnitMismatch { unit1: String, unit2: String },

    /// Validation error
    #[error("Validation error: {0}")]
    Validation(String),

    /// Storage operation error
    #[error("Storage error: {0}")]
    Storage(String),

    /// Serialization/deserialization error
    #[error("Serialization error: {0}")]
    Serialization(String),

    /// Generic error for custom use cases
    #[error("{0}")]
    Custom(String),
}

impl Error {
    /// Create a missing field error
    pub fn missing_field(field: impl Into<String>) -> Self {
        Error::MissingField(field.into())
    }

    /// Create an invalid value error
    pub fn invalid_value(field: impl Into<String>, message: impl Into<String>) -> Self {
        Error::InvalidValue {
            field: field.into(),
            message: message.into(),
        }
    }

    /// Create a not found error
    pub fn not_found(entity_type: impl Into<String>, id: impl Into<String>) -> Self {
        Error::NotFound {
            entity_type: entity_type.into(),
            id: id.into(),
        }
    }

    /// Create a duplicate error
    pub fn duplicate(entity_type: impl Into<String>, id: impl Into<String>) -> Self {
        Error::Duplicate {
            entity_type: entity_type.into(),
            id: id.into(),
        }
    }

    /// Create an invalid action error
    pub fn invalid_action(action: impl Into<String>, context: impl Into<String>) -> Self {
        Error::InvalidAction {
            action: action.into(),
            context: context.into(),
        }
    }

    /// Create a validation error
    pub fn validation(message: impl Into<String>) -> Self {
        Error::Validation(message.into())
    }

    /// Create a storage error
    pub fn storage(message: impl Into<String>) -> Self {
        Error::Storage(message.into())
    }

    /// Create a custom error
    pub fn custom(message: impl Into<String>) -> Self {
        Error::Custom(message.into())
    }
}

#[cfg(feature = "serde")]
impl From<serde_json::Error> for Error {
    fn from(err: serde_json::Error) -> Self {
        Error::Serialization(err.to_string())
    }
}