From: Ian Jackson Date: Sat, 18 Jul 2020 11:41:19 +0000 (+0100) Subject: slotmap-slot-idx compiles, wip X-Git-Tag: otter-0.2.0~1305 X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=commitdiff_plain;h=886a9eada55d7e3150cdbe4d98d9f96315af0b2e;p=otter.git slotmap-slot-idx compiles, wip --- diff --git a/src/lib.rs b/src/lib.rs index 13010239..3c2d8cd2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -12,3 +12,4 @@ pub mod error; pub mod http; pub mod session; pub mod api; +#[path="slotmap-slot-idx.rs"] pub mod slotmap_slot_idx; diff --git a/src/slotmap-slot-idx.rs b/src/slotmap-slot-idx.rs new file mode 100644 index 00000000..9560393c --- /dev/null +++ b/src/slotmap-slot-idx.rs @@ -0,0 +1,144 @@ + +use serde::ser::{self,*}; +use thiserror::Error; +use std::line; + +#[derive(Error,Debug)] +enum Error { + WasCustomSerialize, + Unexpected(std::num::NonZeroU32), +} + +struct MainExtractor { + idx: Option, + version: Option, +} + +struct ValueExtractor; + +type R = Result; +type ROk = R<()>; + + +fn unexpected(line: u32) -> R { Err(Error::Unexpected(std::convert::TryFrom::try_from(line).unwrap())) } + +type Imp = Impossible<(),Error>; + +impl Serializer for &mut MainExtractor { + type Ok = (); + type Error = Error; + + type SerializeStruct = Self; + + type SerializeMap = Imp; + type SerializeSeq = Imp; + type SerializeTuple = Imp; + type SerializeTupleStruct = Imp; + type SerializeTupleVariant = Imp; + type SerializeStructVariant = Imp; + + fn serialize_struct(self, _:&str, _: usize) -> R { Ok(self) } + + fn serialize_bool (self, _: bool ) -> ROk { unexpected(line!()) } + fn serialize_i8 (self, _: i8 ) -> ROk { unexpected(line!()) } + fn serialize_i16 (self, _: i16 ) -> ROk { unexpected(line!()) } + fn serialize_i32 (self, _: i32 ) -> ROk { unexpected(line!()) } + fn serialize_i64 (self, _: i64 ) -> ROk { unexpected(line!()) } + fn serialize_u8 (self, _: u8 ) -> ROk { unexpected(line!()) } + fn serialize_u16 (self, _: u16 ) -> ROk { unexpected(line!()) } + fn serialize_u32 (self, _: u32 ) -> ROk { unexpected(line!()) } + fn serialize_u64 (self, _: u64 ) -> ROk { unexpected(line!()) } + fn serialize_f32 (self, _: f32 ) -> ROk { unexpected(line!()) } + fn serialize_f64 (self, _: f64 ) -> ROk { unexpected(line!()) } + fn serialize_char (self, _: char ) -> ROk { unexpected(line!()) } + fn serialize_str (self, _: &str ) -> ROk { unexpected(line!()) } + fn serialize_bytes(self, _: &[u8 ]) -> ROk { unexpected(line!()) } + fn serialize_none (self) -> ROk { unexpected(line!()) } + fn serialize_unit (self) -> ROk { unexpected(line!()) } + + fn serialize_some (self, _: &T) -> ROk { unexpected(line!()) } + fn serialize_newtype_struct (self, _:&str, _: &T) -> ROk { unexpected(line!()) } + fn serialize_newtype_variant(self, _:&str, _:u32, _:&str, _: &T) -> ROk { unexpected(line!()) } + + fn serialize_unit_struct (self, _: &str ) -> ROk { unexpected(line!()) } + fn serialize_unit_variant (self, _: &str, _:u32, _:&str ) -> ROk { unexpected(line!()) } + fn serialize_seq (self, _: Option ) -> R { unexpected(line!()) } + fn serialize_tuple (self, _: usize ) -> R { unexpected(line!()) } + fn serialize_tuple_struct (self, _: &str, _: usize ) -> R { unexpected(line!()) } + fn serialize_tuple_variant (self, _: &str, _: u32, _: &str, _: usize) -> R { unexpected(line!()) } + fn serialize_map (self, _: std::option::Option ) -> R { unexpected(line!()) } + fn serialize_struct_variant (self, _: &str, _: u32, _: &str, _: usize) -> R { unexpected(line!()) } +} + +impl SerializeStruct for &mut MainExtractor { + type Ok = (); + type Error = Error; + + fn serialize_field ( + &mut self, key: &str, value: &T + ) -> R<()> { + if key == "idx" { self.idx = Some(value.serialize(ValueExtractor)?); } + if key == "version" { self.version = Some(value.serialize(ValueExtractor)?); } + Ok(()) + } + + fn end(self) -> ROk { Ok(()) } +} + +type V = u32; +type ImpV = Impossible; + +impl Serializer for ValueExtractor { + type Ok = V; + type Error = Error; + + fn serialize_u32(self, value: u32) -> R { Ok(value) } + + type SerializeStruct = ImpV; + type SerializeMap = ImpV; + type SerializeSeq = ImpV; + type SerializeTuple = ImpV; + type SerializeTupleStruct = ImpV; + type SerializeTupleVariant = ImpV; + type SerializeStructVariant = ImpV; + + fn serialize_bool (self, _: bool ) -> R { unexpected(line!()) } + fn serialize_i8 (self, _: i8 ) -> R { unexpected(line!()) } + fn serialize_i16 (self, _: i16 ) -> R { unexpected(line!()) } + fn serialize_i32 (self, _: i32 ) -> R { unexpected(line!()) } + fn serialize_i64 (self, _: i64 ) -> R { unexpected(line!()) } + fn serialize_u8 (self, _: u8 ) -> R { unexpected(line!()) } + fn serialize_u16 (self, _: u16 ) -> R { unexpected(line!()) } + fn serialize_u64 (self, _: u64 ) -> R { unexpected(line!()) } + fn serialize_f32 (self, _: f32 ) -> R { unexpected(line!()) } + fn serialize_f64 (self, _: f64 ) -> R { unexpected(line!()) } + fn serialize_char (self, _: char ) -> R { unexpected(line!()) } + fn serialize_str (self, _: &str ) -> R { unexpected(line!()) } + fn serialize_bytes(self, _: &[u8 ]) -> R { unexpected(line!()) } + fn serialize_none (self) -> R { unexpected(line!()) } + fn serialize_unit (self) -> R { unexpected(line!()) } + + fn serialize_some (self, _: &T) -> R { unexpected(line!()) } + fn serialize_newtype_struct (self, _:&str, _: &T) -> R { unexpected(line!()) } + fn serialize_newtype_variant(self, _:&str, _:u32, _:&str, _: &T) -> R { unexpected(line!()) } + + fn serialize_unit_struct (self, _: &str ) -> R { unexpected(line!()) } + fn serialize_unit_variant (self, _: &str, _:u32, _:&str ) -> R { unexpected(line!()) } + fn serialize_seq (self, _: Option ) -> R { unexpected(line!()) } + fn serialize_tuple (self, _: usize ) -> R { unexpected(line!()) } + fn serialize_tuple_struct (self, _: &str, _: usize ) -> R { unexpected(line!()) } + fn serialize_tuple_variant (self, _: &str, _: u32, _: &str, _: usize) -> R { unexpected(line!()) } + fn serialize_struct (self, _: &str, _: usize ) -> R { unexpected(line!()) } + fn serialize_map (self, _: std::option::Option ) -> R { unexpected(line!()) } + fn serialize_struct_variant (self, _: &str, _: u32, _: &str, _: usize) -> R { unexpected(line!()) } +} + +impl ser::Error for Error { + fn custom(_msg: T) -> Self { return Error::WasCustomSerialize; } +} + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { + std::fmt::Debug::fmt(self,f) + } +}