#![allow(clippy::borrowed_box)]
use core::fmt::{self, Debug};
use core::ops::{Deref, DerefMut};
use core::marker::PhantomData;
use ::serde::{
Serialize, Serializer, Deserialize, Deserializer,
ser::{SerializeStruct, SerializeSeq},
de::{self, Visitor, SeqAccess, MapAccess}
};
use crate::clock::TimestampOps;
use super::*;
use super::super::{VFNullDevice, BusDevice};
pub trait SerializeDynDevice {
fn serialize_dyn_device<T: TimestampOps + Serialize + 'static,
S: Serializer>(
device: &Box<dyn NamedBusDevice<T>>,
serializer: S
) -> Result<S::Ok, S::Error>;
}
pub trait DeserializeDynDevice<'de> {
fn deserialize_dyn_device<T: Default + TimestampOps + Deserialize<'de> + 'static,
D: Deserializer<'de>>(
deserializer: D
) -> Result<Box<dyn NamedBusDevice<T>>, D::Error>;
}
pub type DynamicSerdeVBus<S, V> = DynamicSerdeBus<S, VFNullDevice<V>>;
#[repr(transparent)]
pub struct DynamicSerdeBus<S, D: BusDevice>(DynamicBus<D>, PhantomData<S>);
impl<SDD, B> Serialize for DynamicSerdeBus<SDD, B>
where SDD: SerializeDynDevice,
B: BusDevice + Serialize,
B::Timestamp: TimestampOps + Serialize + 'static
{
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
struct DevWrap<'a, T, SDD>(
&'a Box<dyn NamedBusDevice<T>>, PhantomData<SDD>
);
impl<'a, T, SDD> Serialize for DevWrap<'a, T, SDD>
where T: TimestampOps + Serialize + 'static,
SDD: SerializeDynDevice
{
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
SDD::serialize_dyn_device(self.0, serializer)
}
}
struct SliceDevWrap<'a, T, SDD>(&'a [BoxNamedDynDevice<T>], PhantomData<SDD>);
impl<'a, T, SDD> Serialize for SliceDevWrap<'a, T, SDD>
where T: TimestampOps + Serialize + 'static,
SDD: SerializeDynDevice
{
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut seq = serializer.serialize_seq(Some(self.0.len()))?;
for device in self.0 {
seq.serialize_element(&DevWrap::<T, SDD>(device, PhantomData))?;
}
seq.end()
}
}
let mut state = serializer.serialize_struct("DynamicBus", 2)?;
state.serialize_field("bus", &self.0.bus)?;
let devices = SliceDevWrap::<B::Timestamp, SDD>(&self.0.devices, PhantomData);
state.serialize_field("devices", &devices)?;
state.end()
}
}
impl<'de, DDD, B> Deserialize<'de> for DynamicSerdeBus<DDD, B>
where DDD: DeserializeDynDevice<'de> + 'de,
B: BusDevice + Deserialize<'de> + Default,
B::Timestamp: Default + TimestampOps + Deserialize<'de> + 'static
{
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
struct BoxedDevWrap<'de, T, DDD>(
BoxNamedDynDevice<T>, PhantomData<&'de DDD>
);
impl<'de, T, DDD> Deserialize<'de> for BoxedDevWrap<'de, T, DDD>
where T: Default + TimestampOps + Deserialize<'de> + 'static,
DDD: DeserializeDynDevice<'de>
{
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
Ok(BoxedDevWrap(DDD::deserialize_dyn_device(deserializer)?, PhantomData))
}
}
struct DevicesWrap<'de, T, DDD>(
Vec<BoxNamedDynDevice<T>>, PhantomData<&'de DDD>
);
impl<'de, T, DDD> Deserialize<'de> for DevicesWrap<'de, T, DDD>
where T: Default + TimestampOps + Deserialize<'de> + 'static,
DDD: DeserializeDynDevice<'de>
{
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
struct SeqDevVisitor<T, DDD>(PhantomData<T>, PhantomData<DDD>);
impl<'de, T, DDD> Visitor<'de> for SeqDevVisitor<T, DDD>
where T: Default + TimestampOps + Deserialize<'de> + 'static,
DDD: DeserializeDynDevice<'de> + 'de
{
type Value = DevicesWrap<'de, T, DDD>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("a sequence of dynamic bus devices")
}
fn visit_seq<V: SeqAccess<'de>>(self, mut seq: V) -> Result<Self::Value, V::Error> {
let mut vec = Vec::new();
if let Some(size) = seq.size_hint() {
vec.reserve_exact(size);
}
while let Some(BoxedDevWrap::<T, DDD>(dev, ..)) = seq.next_element()? {
vec.push(dev);
}
Ok(DevicesWrap(vec, PhantomData))
}
}
deserializer.deserialize_seq(SeqDevVisitor::<T, DDD>(PhantomData, PhantomData))
}
}
#[derive(Deserialize)]
#[serde(field_identifier, rename_all = "lowercase")]
enum Field { Bus, Devices }
struct DynamicBusVisitor<DDD, B>(PhantomData<DDD>, PhantomData<B>);
impl<'de, DDD, B> Visitor<'de> for DynamicBusVisitor<DDD, B>
where DDD: DeserializeDynDevice<'de> + 'de,
B: BusDevice + Deserialize<'de> + Default,
B::Timestamp: Default + TimestampOps + Deserialize<'de> + 'static
{
type Value = DynamicSerdeBus<DDD, B>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("struct DynamicBus")
}
fn visit_seq<V: SeqAccess<'de>>(self, mut seq: V) -> Result<Self::Value, V::Error> {
let bus = seq.next_element()?.unwrap_or_default();
let DevicesWrap::<B::Timestamp, DDD>(devices, ..) = seq.next_element()?
.unwrap_or_else(|| DevicesWrap(Vec::new(), PhantomData));
Ok(DynamicSerdeBus(DynamicBus { devices, bus }, PhantomData))
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let mut devices = Vec::new();
let mut bus = None;
while let Some(key) = map.next_key()? {
match key {
Field::Bus => {
if bus.is_some() {
return Err(de::Error::duplicate_field("bus"));
}
bus = Some(map.next_value()?);
}
Field::Devices => {
if !devices.is_empty() {
return Err(de::Error::duplicate_field("devices"));
}
devices = map.next_value::<DevicesWrap<B::Timestamp, DDD>>()?.0;
}
}
}
let bus = bus.unwrap_or_default();
Ok(DynamicSerdeBus(DynamicBus { devices, bus }, PhantomData))
}
}
const FIELDS: &[&str] = &["bus", "devices"];
deserializer.deserialize_struct("DynamicBus", FIELDS,
DynamicBusVisitor::<DDD, B>(PhantomData, PhantomData))
}
}
impl<S, D> Default for DynamicSerdeBus<S, D>
where D: BusDevice + Default,
D::Timestamp: Default
{
fn default() -> Self {
DynamicSerdeBus(DynamicBus::default(), PhantomData)
}
}
impl<S, D> fmt::Debug for DynamicSerdeBus<S, D>
where D: BusDevice + fmt::Debug,
D::Timestamp: fmt::Debug
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}
impl<S, D: BusDevice> Deref for DynamicSerdeBus<S, D> {
type Target = DynamicBus<D>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<S, D: BusDevice> DerefMut for DynamicSerdeBus<S, D> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl<S, D: BusDevice> From<DynamicBus<D>> for DynamicSerdeBus<S, D> {
fn from(dynamic_bus: DynamicBus<D>) -> Self {
DynamicSerdeBus(dynamic_bus, PhantomData)
}
}
impl<S, D: BusDevice> From<DynamicSerdeBus<S, D>> for DynamicBus<D> {
fn from(dynamic_bus: DynamicSerdeBus<S, D>) -> Self {
dynamic_bus.0
}
}
impl<S, D: BusDevice> BusDevice for DynamicSerdeBus<S, D>
where D: BusDevice,
D::Timestamp: Copy + Debug
{
type Timestamp = D::Timestamp;
type NextDevice = D;
#[inline(always)]
fn next_device_mut(&mut self) -> &mut Self::NextDevice {
self.0.next_device_mut()
}
#[inline(always)]
fn next_device_ref(&self) -> &Self::NextDevice {
self.0.next_device_ref()
}
#[inline(always)]
fn into_next_device(self) -> Self::NextDevice {
self.0.into_next_device()
}
#[inline(always)]
fn reset(&mut self, timestamp: Self::Timestamp) {
self.0.reset(timestamp)
}
#[inline(always)]
fn update_timestamp(&mut self, timestamp: Self::Timestamp) {
self.0.update_timestamp(timestamp)
}
#[inline(always)]
fn next_frame(&mut self, timestamp: Self::Timestamp) {
self.0.next_frame(timestamp)
}
#[inline(always)]
fn read_io(&mut self, port: u16, timestamp: Self::Timestamp) -> Option<(u8, Option<NonZeroU16>)> {
self.0.read_io(port, timestamp)
}
#[inline(always)]
fn write_io(&mut self, port: u16, data: u8, timestamp: Self::Timestamp) -> Option<u16> {
self.0.write_io(port, data, timestamp)
}
}