use alloc::borrow::Cow;
use alloc::string::{String, ToString};
use core::fmt;
use serde_json::value::RawValue;
use crate::types::MessageId;
use crate::version::Version;
use super::error::{CallErrorRef, ErrorCode};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum MessageTypeId {
Call = 2,
CallResult = 3,
CallError = 4,
CallResultError = 5,
Send = 6,
}
impl MessageTypeId {
#[must_use]
pub const fn from_number(number: u8) -> Option<Self> {
Some(match number {
2 => MessageTypeId::Call,
3 => MessageTypeId::CallResult,
4 => MessageTypeId::CallError,
5 => MessageTypeId::CallResultError,
6 => MessageTypeId::Send,
_ => return None,
})
}
#[must_use]
pub const fn number(self) -> u8 {
self as u8
}
#[must_use]
pub const fn is_defined_in(self, version: Version) -> bool {
match self {
MessageTypeId::CallResultError | MessageTypeId::Send => {
version.has_extended_message_types()
}
_ => true,
}
}
}
impl fmt::Display for MessageTypeId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
MessageTypeId::Call => "CALL",
MessageTypeId::CallResult => "CALLRESULT",
MessageTypeId::CallError => "CALLERROR",
MessageTypeId::CallResultError => "CALLRESULTERROR",
MessageTypeId::Send => "SEND",
})
}
}
#[derive(Clone, Debug)]
pub enum Frame<'a> {
Call {
id: MessageId,
action: Cow<'a, str>,
payload: Cow<'a, RawValue>,
},
CallResult {
id: MessageId,
payload: Cow<'a, RawValue>,
},
CallError {
id: MessageId,
error: CallErrorRef<'a>,
},
CallResultError {
id: MessageId,
error: CallErrorRef<'a>,
},
Send {
id: MessageId,
action: Cow<'a, str>,
payload: Cow<'a, RawValue>,
},
}
impl PartialEq for Frame<'_> {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(
Frame::Call {
id: a,
action: aa,
payload: ap,
},
Frame::Call {
id: b,
action: ba,
payload: bp,
},
)
| (
Frame::Send {
id: a,
action: aa,
payload: ap,
},
Frame::Send {
id: b,
action: ba,
payload: bp,
},
) => a == b && aa == ba && ap.get() == bp.get(),
(
Frame::CallResult { id: a, payload: ap },
Frame::CallResult { id: b, payload: bp },
) => a == b && ap.get() == bp.get(),
(Frame::CallError { id: a, error: ae }, Frame::CallError { id: b, error: be })
| (
Frame::CallResultError { id: a, error: ae },
Frame::CallResultError { id: b, error: be },
) => a == b && ae == be,
_ => false,
}
}
}
impl<'a> Frame<'a> {
#[must_use]
pub const fn message_type(&self) -> MessageTypeId {
match self {
Frame::Call { .. } => MessageTypeId::Call,
Frame::CallResult { .. } => MessageTypeId::CallResult,
Frame::CallError { .. } => MessageTypeId::CallError,
Frame::CallResultError { .. } => MessageTypeId::CallResultError,
Frame::Send { .. } => MessageTypeId::Send,
}
}
#[must_use]
pub fn id(&self) -> &MessageId {
match self {
Frame::Call { id, .. }
| Frame::CallResult { id, .. }
| Frame::CallError { id, .. }
| Frame::CallResultError { id, .. }
| Frame::Send { id, .. } => id,
}
}
#[must_use]
pub fn action(&self) -> Option<&str> {
match self {
Frame::Call { action, .. } | Frame::Send { action, .. } => Some(action),
_ => None,
}
}
#[must_use]
pub fn payload(&self) -> Option<&RawValue> {
match self {
Frame::Call { payload, .. }
| Frame::CallResult { payload, .. }
| Frame::Send { payload, .. } => Some(payload),
_ => None,
}
}
pub fn parse(text: &'a str, version: Version) -> Result<Self, FrameError> {
let elements: alloc::vec::Vec<&'a RawValue> =
serde_json::from_str(text).map_err(|_| FrameError::NotAnArray)?;
let number = elements
.first()
.and_then(|e| serde_json::from_str::<i64>(e.get()).ok())
.ok_or(FrameError::NotAnArray)?;
let Some(message_type) = u8::try_from(number)
.ok()
.and_then(MessageTypeId::from_number)
else {
return Err(FrameError::UnknownMessageType {
number: raw_number(&elements),
});
};
if !message_type.is_defined_in(version) {
return Err(FrameError::MessageTypeNotInVersion {
message_type,
version,
});
}
let (arity, minimum) = match message_type {
MessageTypeId::Call | MessageTypeId::Send => (4, 4),
MessageTypeId::CallResult => (3, 3),
MessageTypeId::CallError | MessageTypeId::CallResultError => (5, 3),
};
if elements.len() < minimum {
return Err(FrameError::WrongArity {
message_type,
found: elements.len(),
expected: arity,
});
}
let id = string_at(&elements, 1).ok_or(FrameError::UnreadableMessageId { message_type })?;
if id.is_empty() {
return Err(FrameError::UnreadableMessageId { message_type });
}
let id = MessageId::from_wire(&id);
Ok(match message_type {
MessageTypeId::Call | MessageTypeId::Send => {
let action = string_at(&elements, 2)
.ok_or(FrameError::UnreadableAction { id: id.clone() })?;
let payload = Cow::Borrowed(elements[3]);
if message_type == MessageTypeId::Call {
Frame::Call {
id,
action: Cow::Owned(action),
payload,
}
} else {
Frame::Send {
id,
action: Cow::Owned(action),
payload,
}
}
}
MessageTypeId::CallResult => Frame::CallResult {
id,
payload: Cow::Borrowed(elements[2]),
},
MessageTypeId::CallError | MessageTypeId::CallResultError => {
let code = string_at(&elements, 2)
.ok_or_else(|| FrameError::UnreadableErrorCode { id: id.clone() })?;
let description = string_at(&elements, 3).unwrap_or_default();
let details = match elements.get(4) {
Some(raw) => Cow::Borrowed(*raw),
None => Cow::Owned(
RawValue::from_string(String::from("{}")).expect("`{}` is valid JSON"),
),
};
let error = CallErrorRef {
code: ErrorCode::parse(&code),
description: Cow::Owned(description),
details,
};
if message_type == MessageTypeId::CallError {
Frame::CallError { id, error }
} else {
Frame::CallResultError { id, error }
}
}
})
}
pub fn to_json(&self, version: Version) -> Result<String, serde_json::Error> {
match self {
Frame::Call {
id,
action,
payload,
} => serde_json::to_string(&(2u8, id.as_str(), action.as_ref(), payload.as_ref())),
Frame::CallResult { id, payload } => {
serde_json::to_string(&(3u8, id.as_str(), payload.as_ref()))
}
Frame::CallError { id, error } => serde_json::to_string(&(
4u8,
id.as_str(),
error.code.as_wire(version),
error.description.as_ref(),
error.details.as_ref(),
)),
Frame::CallResultError { id, error } => serde_json::to_string(&(
5u8,
id.as_str(),
error.code.as_wire(version),
error.description.as_ref(),
error.details.as_ref(),
)),
Frame::Send {
id,
action,
payload,
} => serde_json::to_string(&(6u8, id.as_str(), action.as_ref(), payload.as_ref())),
}
}
#[must_use]
pub fn into_owned(self) -> Frame<'static> {
fn own(value: Cow<'_, RawValue>) -> Cow<'static, RawValue> {
Cow::Owned(value.into_owned())
}
match self {
Frame::Call {
id,
action,
payload,
} => Frame::Call {
id,
action: Cow::Owned(action.into_owned()),
payload: own(payload),
},
Frame::CallResult { id, payload } => Frame::CallResult {
id,
payload: own(payload),
},
Frame::Send {
id,
action,
payload,
} => Frame::Send {
id,
action: Cow::Owned(action.into_owned()),
payload: own(payload),
},
Frame::CallError { id, error } => Frame::CallError {
id,
error: error.into_owned(),
},
Frame::CallResultError { id, error } => Frame::CallResultError {
id,
error: error.into_owned(),
},
}
}
}
fn string_at(elements: &[&RawValue], index: usize) -> Option<String> {
let raw = elements.get(index)?;
serde_json::from_str::<String>(raw.get()).ok()
}
fn raw_number(elements: &[&RawValue]) -> String {
elements
.first()
.map_or_else(|| "?".to_string(), |e| e.get().to_string())
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum FrameError {
NotAnArray,
WrongArity {
message_type: MessageTypeId,
found: usize,
expected: usize,
},
UnknownMessageType {
number: String,
},
MessageTypeNotInVersion {
message_type: MessageTypeId,
version: Version,
},
UnreadableMessageId {
message_type: MessageTypeId,
},
UnreadableAction {
id: MessageId,
},
UnreadableErrorCode {
id: MessageId,
},
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum FrameReply {
Ignore,
CallError,
CallResultError,
}
impl FrameError {
#[must_use]
pub fn message_type(&self) -> Option<MessageTypeId> {
match self {
FrameError::WrongArity { message_type, .. }
| FrameError::MessageTypeNotInVersion { message_type, .. }
| FrameError::UnreadableMessageId { message_type } => Some(*message_type),
_ => None,
}
}
#[must_use]
pub fn reply(&self, version: Version) -> FrameReply {
if self.is_ignorable() {
return FrameReply::Ignore;
}
match self.message_type() {
Some(MessageTypeId::CallResult) => {
if version.has_extended_message_types() {
FrameReply::CallResultError
} else {
FrameReply::Ignore
}
}
Some(
MessageTypeId::Send | MessageTypeId::CallError | MessageTypeId::CallResultError,
) => FrameReply::Ignore,
Some(MessageTypeId::Call) | None => FrameReply::CallError,
}
}
#[must_use]
pub fn is_ignorable(&self) -> bool {
matches!(
self,
FrameError::UnknownMessageType { .. } | FrameError::MessageTypeNotInVersion { .. }
)
}
#[must_use]
pub fn error_code(&self) -> ErrorCode {
match self {
FrameError::UnknownMessageType { .. } | FrameError::MessageTypeNotInVersion { .. } => {
ErrorCode::MessageTypeNotSupported
}
_ => ErrorCode::RpcFrameworkError,
}
}
#[must_use]
pub fn reply_id(&self) -> MessageId {
match self {
FrameError::UnreadableAction { id } | FrameError::UnreadableErrorCode { id } => {
id.clone()
}
_ => MessageId::unreadable(),
}
}
}
impl fmt::Display for FrameError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
FrameError::NotAnArray => f.write_str("frame is not a JSON array with a message type"),
FrameError::WrongArity {
message_type,
found,
expected,
} => {
write!(f, "{message_type} needs {expected} elements, got {found}")
}
FrameError::UnknownMessageType { number } => {
write!(f, "unknown message type number {number}")
}
FrameError::MessageTypeNotInVersion {
message_type,
version,
} => {
write!(f, "{message_type} is not defined in OCPP {version}")
}
FrameError::UnreadableMessageId { message_type } => {
write!(f, "the MessageId of a {message_type} could not be read")
}
FrameError::UnreadableAction { .. } => f.write_str("action could not be read"),
FrameError::UnreadableErrorCode { .. } => f.write_str("error code could not be read"),
}
}
}
#[cfg(feature = "std")]
impl std::error::Error for FrameError {}