use serde::Deserialize;
use serde::Deserializer;
use serde::Serialize;
use serde::Serializer;
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum CodeModeLanguage {
Javascript,
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum CodeModeOutputStream {
Transcript,
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct CodeModeOutputSpan {
pub stream: CodeModeOutputStream,
pub offset_bytes: u64,
pub length_bytes: u64,
}
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct CodeModeReceipt {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub language: Option<CodeModeLanguage>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub source_arg: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cell_item_id: Option<String>,
#[serde(default, skip_serializing_if = "spans_absent")]
pub output_spans: Option<Vec<CodeModeOutputSpan>>,
}
fn spans_absent(spans: &Option<Vec<CodeModeOutputSpan>>) -> bool {
spans.as_ref().is_none_or(Vec::is_empty)
}
impl CodeModeReceipt {
#[must_use]
pub fn serializes_empty(&self) -> bool {
self.language.is_none()
&& self.source_arg.is_none()
&& self.cell_item_id.is_none()
&& spans_absent(&self.output_spans)
}
}
impl CodeModeLanguage {
fn decode_word(word: &str) -> Self {
match word {
"javascript" => Self::Javascript,
_ => Self::Unknown(word.to_owned()),
}
}
#[must_use]
pub fn as_str(&self) -> &str {
match self {
Self::Javascript => "javascript",
Self::Unknown(value) => value,
}
}
}
impl Serialize for CodeModeLanguage {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> Deserialize<'de> for CodeModeLanguage {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = String::deserialize(deserializer)?;
Ok(Self::decode_word(&value))
}
}
impl CodeModeOutputStream {
fn decode_word(word: &str) -> Self {
match word {
"transcript" => Self::Transcript,
_ => Self::Unknown(word.to_owned()),
}
}
#[must_use]
pub fn as_str(&self) -> &str {
match self {
Self::Transcript => "transcript",
Self::Unknown(value) => value,
}
}
}
impl Serialize for CodeModeOutputStream {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> Deserialize<'de> for CodeModeOutputStream {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = String::deserialize(deserializer)?;
Ok(Self::decode_word(&value))
}
}