1use alloc::borrow::Cow;
10use alloc::string::{String, ToString};
11use core::fmt;
12
13use serde_json::value::RawValue;
14
15use crate::types::MessageId;
16use crate::version::Version;
17
18use super::error::{CallErrorRef, ErrorCode};
19
20#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
22#[repr(u8)]
23pub enum MessageTypeId {
24 Call = 2,
26 CallResult = 3,
28 CallError = 4,
30 CallResultError = 5,
32 Send = 6,
34}
35
36impl MessageTypeId {
37 #[must_use]
39 pub const fn from_number(number: u8) -> Option<Self> {
40 Some(match number {
41 2 => MessageTypeId::Call,
42 3 => MessageTypeId::CallResult,
43 4 => MessageTypeId::CallError,
44 5 => MessageTypeId::CallResultError,
45 6 => MessageTypeId::Send,
46 _ => return None,
47 })
48 }
49
50 #[must_use]
52 pub const fn number(self) -> u8 {
53 self as u8
54 }
55
56 #[must_use]
60 pub const fn is_defined_in(self, version: Version) -> bool {
61 match self {
62 MessageTypeId::CallResultError | MessageTypeId::Send => {
63 version.has_extended_message_types()
64 }
65 _ => true,
66 }
67 }
68}
69
70impl fmt::Display for MessageTypeId {
71 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
72 f.write_str(match self {
73 MessageTypeId::Call => "CALL",
74 MessageTypeId::CallResult => "CALLRESULT",
75 MessageTypeId::CallError => "CALLERROR",
76 MessageTypeId::CallResultError => "CALLRESULTERROR",
77 MessageTypeId::Send => "SEND",
78 })
79 }
80}
81
82#[derive(Clone, Debug)]
86pub enum Frame<'a> {
87 Call {
89 id: MessageId,
91 action: Cow<'a, str>,
93 payload: Cow<'a, RawValue>,
95 },
96 CallResult {
98 id: MessageId,
100 payload: Cow<'a, RawValue>,
102 },
103 CallError {
105 id: MessageId,
107 error: CallErrorRef<'a>,
109 },
110 CallResultError {
115 id: MessageId,
117 error: CallErrorRef<'a>,
119 },
120 Send {
125 id: MessageId,
127 action: Cow<'a, str>,
129 payload: Cow<'a, RawValue>,
131 },
132}
133
134impl PartialEq for Frame<'_> {
135 fn eq(&self, other: &Self) -> bool {
138 match (self, other) {
139 (
140 Frame::Call {
141 id: a,
142 action: aa,
143 payload: ap,
144 },
145 Frame::Call {
146 id: b,
147 action: ba,
148 payload: bp,
149 },
150 )
151 | (
152 Frame::Send {
153 id: a,
154 action: aa,
155 payload: ap,
156 },
157 Frame::Send {
158 id: b,
159 action: ba,
160 payload: bp,
161 },
162 ) => a == b && aa == ba && ap.get() == bp.get(),
163 (
164 Frame::CallResult { id: a, payload: ap },
165 Frame::CallResult { id: b, payload: bp },
166 ) => a == b && ap.get() == bp.get(),
167 (Frame::CallError { id: a, error: ae }, Frame::CallError { id: b, error: be })
168 | (
169 Frame::CallResultError { id: a, error: ae },
170 Frame::CallResultError { id: b, error: be },
171 ) => a == b && ae == be,
172 _ => false,
173 }
174 }
175}
176
177impl<'a> Frame<'a> {
178 #[must_use]
180 pub const fn message_type(&self) -> MessageTypeId {
181 match self {
182 Frame::Call { .. } => MessageTypeId::Call,
183 Frame::CallResult { .. } => MessageTypeId::CallResult,
184 Frame::CallError { .. } => MessageTypeId::CallError,
185 Frame::CallResultError { .. } => MessageTypeId::CallResultError,
186 Frame::Send { .. } => MessageTypeId::Send,
187 }
188 }
189
190 #[must_use]
192 pub fn id(&self) -> &MessageId {
193 match self {
194 Frame::Call { id, .. }
195 | Frame::CallResult { id, .. }
196 | Frame::CallError { id, .. }
197 | Frame::CallResultError { id, .. }
198 | Frame::Send { id, .. } => id,
199 }
200 }
201
202 #[must_use]
204 pub fn action(&self) -> Option<&str> {
205 match self {
206 Frame::Call { action, .. } | Frame::Send { action, .. } => Some(action),
207 _ => None,
208 }
209 }
210
211 #[must_use]
213 pub fn payload(&self) -> Option<&RawValue> {
214 match self {
215 Frame::Call { payload, .. }
216 | Frame::CallResult { payload, .. }
217 | Frame::Send { payload, .. } => Some(payload),
218 _ => None,
219 }
220 }
221
222 pub fn parse(text: &'a str, version: Version) -> Result<Self, FrameError> {
228 let elements: alloc::vec::Vec<&'a RawValue> =
229 serde_json::from_str(text).map_err(|_| FrameError::NotAnArray)?;
230
231 let number = elements
234 .first()
235 .and_then(|e| serde_json::from_str::<i64>(e.get()).ok())
236 .ok_or(FrameError::NotAnArray)?;
237
238 let Some(message_type) = u8::try_from(number)
239 .ok()
240 .and_then(MessageTypeId::from_number)
241 else {
242 return Err(FrameError::UnknownMessageType {
243 number: raw_number(&elements),
244 });
245 };
246 if !message_type.is_defined_in(version) {
247 return Err(FrameError::MessageTypeNotInVersion {
248 message_type,
249 version,
250 });
251 }
252
253 let (arity, minimum) = match message_type {
260 MessageTypeId::Call | MessageTypeId::Send => (4, 4),
261 MessageTypeId::CallResult => (3, 3),
262 MessageTypeId::CallError | MessageTypeId::CallResultError => (5, 3),
263 };
264 if elements.len() < minimum {
265 return Err(FrameError::WrongArity {
266 message_type,
267 found: elements.len(),
268 expected: arity,
269 });
270 }
271
272 let id = string_at(&elements, 1).ok_or(FrameError::UnreadableMessageId { message_type })?;
273 if id.is_empty() {
274 return Err(FrameError::UnreadableMessageId { message_type });
275 }
276 let id = MessageId::from_wire(&id);
277
278 Ok(match message_type {
279 MessageTypeId::Call | MessageTypeId::Send => {
280 let action = string_at(&elements, 2)
281 .ok_or(FrameError::UnreadableAction { id: id.clone() })?;
282 let payload = Cow::Borrowed(elements[3]);
283 if message_type == MessageTypeId::Call {
284 Frame::Call {
285 id,
286 action: Cow::Owned(action),
287 payload,
288 }
289 } else {
290 Frame::Send {
291 id,
292 action: Cow::Owned(action),
293 payload,
294 }
295 }
296 }
297 MessageTypeId::CallResult => Frame::CallResult {
298 id,
299 payload: Cow::Borrowed(elements[2]),
300 },
301 MessageTypeId::CallError | MessageTypeId::CallResultError => {
302 let code = string_at(&elements, 2)
303 .ok_or_else(|| FrameError::UnreadableErrorCode { id: id.clone() })?;
304 let description = string_at(&elements, 3).unwrap_or_default();
305 let details = match elements.get(4) {
306 Some(raw) => Cow::Borrowed(*raw),
307 None => Cow::Owned(
310 RawValue::from_string(String::from("{}")).expect("`{}` is valid JSON"),
311 ),
312 };
313 let error = CallErrorRef {
314 code: ErrorCode::parse(&code),
315 description: Cow::Owned(description),
316 details,
317 };
318 if message_type == MessageTypeId::CallError {
319 Frame::CallError { id, error }
320 } else {
321 Frame::CallResultError { id, error }
322 }
323 }
324 })
325 }
326
327 pub fn to_json(&self, version: Version) -> Result<String, serde_json::Error> {
329 match self {
330 Frame::Call {
331 id,
332 action,
333 payload,
334 } => serde_json::to_string(&(2u8, id.as_str(), action.as_ref(), payload.as_ref())),
335 Frame::CallResult { id, payload } => {
336 serde_json::to_string(&(3u8, id.as_str(), payload.as_ref()))
337 }
338 Frame::CallError { id, error } => serde_json::to_string(&(
339 4u8,
340 id.as_str(),
341 error.code.as_wire(version),
342 error.description.as_ref(),
343 error.details.as_ref(),
344 )),
345 Frame::CallResultError { id, error } => serde_json::to_string(&(
346 5u8,
347 id.as_str(),
348 error.code.as_wire(version),
349 error.description.as_ref(),
350 error.details.as_ref(),
351 )),
352 Frame::Send {
353 id,
354 action,
355 payload,
356 } => serde_json::to_string(&(6u8, id.as_str(), action.as_ref(), payload.as_ref())),
357 }
358 }
359
360 #[must_use]
362 pub fn into_owned(self) -> Frame<'static> {
363 fn own(value: Cow<'_, RawValue>) -> Cow<'static, RawValue> {
364 Cow::Owned(value.into_owned())
365 }
366 match self {
367 Frame::Call {
368 id,
369 action,
370 payload,
371 } => Frame::Call {
372 id,
373 action: Cow::Owned(action.into_owned()),
374 payload: own(payload),
375 },
376 Frame::CallResult { id, payload } => Frame::CallResult {
377 id,
378 payload: own(payload),
379 },
380 Frame::Send {
381 id,
382 action,
383 payload,
384 } => Frame::Send {
385 id,
386 action: Cow::Owned(action.into_owned()),
387 payload: own(payload),
388 },
389 Frame::CallError { id, error } => Frame::CallError {
390 id,
391 error: error.into_owned(),
392 },
393 Frame::CallResultError { id, error } => Frame::CallResultError {
394 id,
395 error: error.into_owned(),
396 },
397 }
398 }
399}
400
401fn string_at(elements: &[&RawValue], index: usize) -> Option<String> {
402 let raw = elements.get(index)?;
403 serde_json::from_str::<String>(raw.get()).ok()
404}
405
406fn raw_number(elements: &[&RawValue]) -> String {
407 elements
408 .first()
409 .map_or_else(|| "?".to_string(), |e| e.get().to_string())
410}
411
412#[derive(Clone, Debug, PartialEq, Eq)]
414#[non_exhaustive]
415pub enum FrameError {
416 NotAnArray,
418 WrongArity {
420 message_type: MessageTypeId,
422 found: usize,
424 expected: usize,
426 },
427 UnknownMessageType {
431 number: String,
433 },
434 MessageTypeNotInVersion {
437 message_type: MessageTypeId,
439 version: Version,
441 },
442 UnreadableMessageId {
447 message_type: MessageTypeId,
449 },
450 UnreadableAction {
452 id: MessageId,
454 },
455 UnreadableErrorCode {
457 id: MessageId,
459 },
460}
461
462#[derive(Clone, Copy, Debug, PartialEq, Eq)]
468pub enum FrameReply {
469 Ignore,
472 CallError,
474 CallResultError,
476}
477
478impl FrameError {
479 #[must_use]
481 pub fn message_type(&self) -> Option<MessageTypeId> {
482 match self {
483 FrameError::WrongArity { message_type, .. }
484 | FrameError::MessageTypeNotInVersion { message_type, .. }
485 | FrameError::UnreadableMessageId { message_type } => Some(*message_type),
486 _ => None,
487 }
488 }
489
490 #[must_use]
492 pub fn reply(&self, version: Version) -> FrameReply {
493 if self.is_ignorable(version) {
494 return FrameReply::Ignore;
495 }
496 if matches!(self, FrameError::MessageTypeNotInVersion { .. }) {
500 return FrameReply::CallError;
501 }
502 match self.message_type() {
503 Some(MessageTypeId::CallResult) => {
506 if version.has_extended_message_types() {
507 FrameReply::CallResultError
508 } else {
509 FrameReply::Ignore
510 }
511 }
512 Some(
515 MessageTypeId::Send | MessageTypeId::CallError | MessageTypeId::CallResultError,
516 ) => FrameReply::Ignore,
517 Some(MessageTypeId::Call) | None => FrameReply::CallError,
519 }
520 }
521
522 #[must_use]
527 pub fn is_ignorable(&self, version: Version) -> bool {
528 matches!(
529 self,
530 FrameError::UnknownMessageType { .. } | FrameError::MessageTypeNotInVersion { .. }
531 ) && !matches!(version, Version::V2_0_1)
532 }
533
534 #[must_use]
536 pub fn error_code(&self) -> ErrorCode {
537 match self {
538 FrameError::UnknownMessageType { .. } | FrameError::MessageTypeNotInVersion { .. } => {
539 ErrorCode::MessageTypeNotSupported
540 }
541 _ => ErrorCode::RpcFrameworkError,
542 }
543 }
544
545 #[must_use]
547 pub fn reply_id(&self) -> MessageId {
548 match self {
549 FrameError::UnreadableAction { id } | FrameError::UnreadableErrorCode { id } => {
550 id.clone()
551 }
552 _ => MessageId::unreadable(),
553 }
554 }
555}
556
557impl fmt::Display for FrameError {
558 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
559 match self {
560 FrameError::NotAnArray => f.write_str("frame is not a JSON array with a message type"),
561 FrameError::WrongArity {
562 message_type,
563 found,
564 expected,
565 } => {
566 write!(f, "{message_type} needs {expected} elements, got {found}")
567 }
568 FrameError::UnknownMessageType { number } => {
569 write!(f, "unknown message type number {number}")
570 }
571 FrameError::MessageTypeNotInVersion {
572 message_type,
573 version,
574 } => {
575 write!(f, "{message_type} is not defined in OCPP {version}")
576 }
577 FrameError::UnreadableMessageId { message_type } => {
578 write!(f, "the MessageId of a {message_type} could not be read")
579 }
580 FrameError::UnreadableAction { .. } => f.write_str("action could not be read"),
581 FrameError::UnreadableErrorCode { .. } => f.write_str("error code could not be read"),
582 }
583 }
584}
585
586#[cfg(feature = "std")]
587impl std::error::Error for FrameError {}