use std::{
borrow::Cow,
fmt::{self, Debug, Formatter},
};
use schemars::{JsonSchema, Schema, SchemaGenerator, json_schema};
use serde::{
Deserialize, Deserializer, Serialize, Serializer,
de::{IgnoredAny, MapAccess, SeqAccess, Visitor},
ser::SerializeStruct,
};
pub trait PublicEvidence: Serialize + JsonSchema + Debug + Send + Sync + 'static {}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct NoEvidence;
const NO_EVIDENCE_DESCRIPTION: &str = "Empty public evidence, represented on the wire as `{}`.";
impl PublicEvidence for NoEvidence {}
impl Serialize for NoEvidence {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_struct("NoEvidence", 0)?.end()
}
}
impl<'de> Deserialize<'de> for NoEvidence {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_struct("NoEvidence", &[], NoEvidenceVisitor)
}
}
struct NoEvidenceVisitor;
impl<'de> Visitor<'de> for NoEvidenceVisitor {
type Value = NoEvidence;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("an empty evidence object")
}
fn visit_seq<A>(self, _elements: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
Ok(NoEvidence)
}
fn visit_map<A>(self, mut members: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
while members.next_entry::<IgnoredAny, IgnoredAny>()?.is_some() {}
Ok(NoEvidence)
}
}
impl JsonSchema for NoEvidence {
fn schema_name() -> Cow<'static, str> {
"NoEvidence".into()
}
fn schema_id() -> Cow<'static, str> {
Cow::Borrowed(concat!(module_path!(), "::NoEvidence"))
}
fn json_schema(_generator: &mut SchemaGenerator) -> Schema {
json_schema!({
"description": NO_EVIDENCE_DESCRIPTION,
"type": "object"
})
}
}