hiroz 0.1.0

Native Rust ROS 2 implementation using Zenoh
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Error types for dynamic message handling.

use std::fmt;

/// Errors that can occur during dynamic message operations.
#[derive(Debug)]
pub enum DynamicError {
    /// Invalid type name format (should be "package/msg/Name")
    InvalidTypeName(String),

    /// Field not found in message schema
    FieldNotFound(String),

    /// Empty path provided for field access
    EmptyPath,

    /// Attempted to access a nested field on a non-message type
    NotAMessage(String),

    /// Type mismatch during field access or conversion
    TypeMismatch { path: String, expected: String },

    /// Index out of bounds for field access
    IndexOutOfBounds(usize),

    /// CDR serialization error
    SerializationError(String),

    /// CDR deserialization error
    DeserializationError(String),

    /// Schema loading error
    SchemaLoadError { package: String, source: String },

    /// Registry lock was poisoned
    RegistryLockPoisoned,

    /// Schema not found in registry
    SchemaNotFound(String),

    /// Type description service call timed out — no response from the remote node.
    ServiceTimeout { node: String, service: String },

    /// Automatic topic-based schema discovery requires publisher node identity.
    MissingNodeIdentity { topic: String },

    /// Invalid default value for field type
    InvalidDefaultValue { field: String, reason: String },

    /// Bounded string/sequence exceeded maximum size
    BoundExceeded { max: usize, actual: usize },
}

impl fmt::Display for DynamicError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DynamicError::InvalidTypeName(name) => {
                write!(
                    f,
                    "Invalid type name '{}': expected format 'package/msg/Name'",
                    name
                )
            }
            DynamicError::FieldNotFound(name) => {
                write!(f, "Field '{}' not found in message schema", name)
            }
            DynamicError::EmptyPath => {
                write!(f, "Empty path provided for field access")
            }
            DynamicError::NotAMessage(name) => {
                write!(
                    f,
                    "Field '{}' is not a message type, cannot access nested fields",
                    name
                )
            }
            DynamicError::TypeMismatch { path, expected } => {
                write!(
                    f,
                    "Type mismatch at '{}': expected type '{}'",
                    path, expected
                )
            }
            DynamicError::IndexOutOfBounds(idx) => {
                write!(f, "Field index {} is out of bounds", idx)
            }
            DynamicError::SerializationError(msg) => {
                write!(f, "CDR serialization error: {}", msg)
            }
            DynamicError::DeserializationError(msg) => {
                write!(f, "CDR deserialization error: {}", msg)
            }
            DynamicError::SchemaLoadError { package, source } => {
                write!(
                    f,
                    "Failed to load schema for package '{}': {}",
                    package, source
                )
            }
            DynamicError::RegistryLockPoisoned => {
                write!(f, "Schema registry lock was poisoned")
            }
            DynamicError::SchemaNotFound(name) => {
                write!(f, "Schema '{}' not found in registry", name)
            }
            DynamicError::ServiceTimeout { node, service } => {
                write!(
                    f,
                    "type description service timed out: no response from node '{}' on service '{}'",
                    node, service
                )
            }
            DynamicError::MissingNodeIdentity { topic } => {
                write!(
                    f,
                    "automatic schema discovery for topic '{}' requires publisher node identity, which is unavailable from this backend/discovery format",
                    topic
                )
            }
            DynamicError::InvalidDefaultValue { field, reason } => {
                write!(f, "Invalid default value for field '{}': {}", field, reason)
            }
            DynamicError::BoundExceeded { max, actual } => {
                write!(
                    f,
                    "Bounded type exceeded maximum size: max={}, actual={}",
                    max, actual
                )
            }
        }
    }
}

impl std::error::Error for DynamicError {}

impl From<hiroz_cdr::Error> for DynamicError {
    fn from(e: hiroz_cdr::Error) -> Self {
        DynamicError::DeserializationError(e.to_string())
    }
}