bendns' repos / treaty
Diffstat (limited to 'src/protocols.rs')
-rw-r--r--src/protocols.rs611
1 files changed, 596 insertions, 15 deletions
diff --git a/src/protocols.rs b/src/protocols.rs
index cd0164e..6e0ae5f 100644
--- a/src/protocols.rs
+++ b/src/protocols.rs
@@ -1,23 +1,120 @@
+pub enum ControlFlow {
+ Done,
+ Error,
+}
+
+pub mod hint {
+ use crate::protocol::{Implementer, Protocol};
+
+ pub enum ControlFlow {
+ HintGiven,
+ NoHint,
+ Error,
+ }
+
+ pub trait Object<'ctx> {
+ fn request_hint(&mut self, hints: &mut dyn Implementer<'ctx>) -> ControlFlow;
+ }
+
+ pub enum RequestHint {}
+
+ impl Protocol for RequestHint {
+ type Object<'a, 'ctx: 'a> = &'a mut dyn Object<'ctx>;
+ }
+
+ pub trait HintObject<'ctx> {
+ fn hint(&mut self, visitor: &mut dyn Implementer<'ctx>) -> ControlFlow;
+ }
+}
+
pub mod recoverable {
- use crate::{protocol::Protocol, ControlFlow, Visitor};
+ use crate::protocol::{Implementer, Protocol};
+
+ use super::{hint::HintObject, ControlFlow};
pub trait Accessor<'ctx> {
- /// Each time this is called the walker resets.
- fn new_walk(&mut self, visitor: &mut dyn Visitor<'ctx>) -> ControlFlow;
+ fn new_walk(&mut self, visitor: &mut dyn Implementer<'ctx>) -> ControlFlow;
+ }
+
+ pub trait Object<'ctx> {
+ fn visit(&mut self, accessor: &mut dyn Accessor<'ctx>) -> ControlFlow;
}
pub enum Recoverable {}
impl Protocol for Recoverable {
- type Hint<'ctx> = ();
+ type Object<'a, 'ctx: 'a> = &'a mut dyn Object<'ctx>;
+ }
- type Known<'ctx> = ();
+ pub enum Hint {}
- type Accessor<'walking, 'ctx: 'walking> = &'walking mut dyn Accessor<'ctx>;
+ impl Protocol for Hint {
+ type Object<'a, 'ctx: 'a> = &'a mut dyn HintObject<'ctx>;
}
}
pub mod sequence {
+ use crate::protocol::{Implementer, Protocol};
+
+ pub enum ControlFlow {
+ Done,
+ Continue,
+ Error,
+ }
+
+ pub trait Accessor<'ctx> {
+ fn next(&mut self, visitor: &mut dyn Implementer<'ctx>) -> ControlFlow;
+ }
+
+ pub trait Object<'ctx> {
+ fn visit(&mut self, accessor: &mut dyn Accessor<'ctx>) -> super::ControlFlow;
+ }
+
+ pub enum Sequence {}
+
+ impl Protocol for Sequence {
+ type Object<'a, 'ctx: 'a> = &'a mut dyn Object<'ctx>;
+ }
+
+ pub trait HintObject<'ctx> {
+ fn hint(&mut self, visitor: &mut dyn Implementer<'ctx>) -> super::ControlFlow;
+
+ fn len(&mut self) -> (usize, Option<usize>) {
+ (0, None)
+ }
+ }
+
+ pub enum Hint {}
+
+ impl Protocol for Hint {
+ type Object<'a, 'ctx: 'a> = &'a mut dyn HintObject<'ctx>;
+ }
+}
+
+pub mod bool {
+ use crate::protocol::Protocol;
+
+ use super::{hint::HintObject, ControlFlow};
+
+ pub trait Object<'ctx> {
+ fn visit(&mut self, value: bool) -> ControlFlow;
+ }
+
+ pub enum Bool {}
+
+ impl Protocol for Bool {
+ type Object<'a, 'ctx: 'a> = &'a mut dyn Object<'ctx>;
+ }
+
+ pub enum Hint {}
+
+ impl Protocol for Hint {
+ type Object<'a, 'ctx: 'a> = &'a mut dyn HintObject<'ctx>;
+ }
+}
+
+/*
+pub mod map {
use crate::{protocol::Protocol, ControlFlow, Visitor};
pub struct Hint {
@@ -30,15 +127,16 @@ pub mod sequence {
}
pub trait Accessor<'ctx> {
- fn next(&mut self, visitor: &mut dyn Visitor<'ctx>) -> ControlFlow;
+ fn next_key(&mut self, visitor: &mut dyn Visitor<'ctx>) -> ControlFlow;
+ fn value(&mut self, visitor: &mut dyn Visitor<'ctx>) -> ControlFlow;
}
- pub enum Sequence {}
+ pub enum Map {}
- impl Protocol for Sequence {
- type Hint<'ctx> = Hint;
+ impl Protocol for Map {
+ type Hint<'walking, 'ctx: 'walking> = Hint;
- type Known<'ctx> = Known;
+ type Known<'walking, 'ctx: 'walking> = Known;
type Accessor<'walking, 'ctx: 'walking> = &'walking mut dyn Accessor<'ctx>;
}
@@ -86,18 +184,501 @@ pub mod reference {
pub struct ReferenceMut<T: ?Sized + Any>(PhantomData<fn() -> T>);
impl<T: ?Sized + Any> Protocol for Reference<T> {
- type Hint<'ctx> = Hint;
+ type Hint<'walking, 'ctx: 'walking> = Hint;
- type Known<'ctx> = Known;
+ type Known<'walking, 'ctx: 'walking> = Known;
type Accessor<'walking, 'ctx: 'walking> = Ref<'walking, 'ctx, T>;
}
impl<T: ?Sized + Any> Protocol for ReferenceMut<T> {
- type Hint<'ctx> = Hint;
+ type Hint<'walking, 'ctx: 'walking> = Hint;
- type Known<'ctx> = Known;
+ type Known<'walking, 'ctx: 'walking> = Known;
type Accessor<'walking, 'ctx: 'walking> = Mut<'walking, 'ctx, T>;
}
}
+
+pub mod bool {
+ use crate::protocol::Protocol;
+
+ pub enum Bool {}
+
+ impl Protocol for Bool {
+ type Hint<'walking, 'ctx: 'walking> = ();
+
+ type Known<'walking, 'ctx: 'walking> = ();
+
+ type Accessor<'walking, 'ctx: 'walking> = bool;
+ }
+}
+
+pub mod int {
+ use core::num::TryFromIntError;
+
+ use crate::protocol::Protocol;
+
+ pub enum Kind {
+ I8,
+ I16,
+ I32,
+ I64,
+ I128,
+ Isize,
+ U8,
+ U16,
+ U32,
+ U64,
+ U128,
+ Usize,
+ }
+
+ pub enum Value {
+ I8(i8),
+ I16(i16),
+ I32(i32),
+ I64(i64),
+ I128(i128),
+ Isize(isize),
+ U8(u8),
+ U16(u16),
+ U32(u32),
+ U64(u64),
+ U128(u128),
+ Usize(usize),
+ }
+
+ pub enum Int {}
+
+ impl Protocol for Int {
+ type Hint<'walking, 'ctx: 'walking> = Option<Kind>;
+
+ type Known<'walking, 'ctx: 'walking> = Option<Kind>;
+
+ type Accessor<'walking, 'ctx: 'walking> = Value;
+ }
+
+ impl From<i8> for Value {
+ fn from(value: i8) -> Self {
+ Self::I8(value)
+ }
+ }
+
+ impl From<i16> for Value {
+ fn from(value: i16) -> Self {
+ Self::I16(value)
+ }
+ }
+
+ impl From<i32> for Value {
+ fn from(value: i32) -> Self {
+ Self::I32(value)
+ }
+ }
+
+ impl From<i64> for Value {
+ fn from(value: i64) -> Self {
+ Self::I64(value)
+ }
+ }
+
+ impl From<i128> for Value {
+ fn from(value: i128) -> Self {
+ Self::I128(value)
+ }
+ }
+
+ impl From<isize> for Value {
+ fn from(value: isize) -> Self {
+ Self::Isize(value)
+ }
+ }
+
+ impl From<u8> for Value {
+ fn from(value: u8) -> Self {
+ Self::U8(value)
+ }
+ }
+
+ impl From<u16> for Value {
+ fn from(value: u16) -> Self {
+ Self::U16(value)
+ }
+ }
+
+ impl From<u32> for Value {
+ fn from(value: u32) -> Self {
+ Self::U32(value)
+ }
+ }
+
+ impl From<u64> for Value {
+ fn from(value: u64) -> Self {
+ Self::U64(value)
+ }
+ }
+
+ impl From<u128> for Value {
+ fn from(value: u128) -> Self {
+ Self::U128(value)
+ }
+ }
+
+ impl From<usize> for Value {
+ fn from(value: usize) -> Self {
+ Self::Usize(value)
+ }
+ }
+
+ impl TryFrom<Value> for i8 {
+ type Error = TryFromIntError;
+
+ fn try_from(value: Value) -> Result<Self, Self::Error> {
+ match value {
+ Value::I8(value) => Ok(value),
+ Value::I16(value) => value.try_into(),
+ Value::I32(value) => value.try_into(),
+ Value::I64(value) => value.try_into(),
+ Value::I128(value) => value.try_into(),
+ Value::Isize(value) => value.try_into(),
+ Value::U8(value) => value.try_into(),
+ Value::U16(value) => value.try_into(),
+ Value::U32(value) => value.try_into(),
+ Value::U64(value) => value.try_into(),
+ Value::U128(value) => value.try_into(),
+ Value::Usize(value) => value.try_into(),
+ }
+ }
+ }
+
+ impl TryFrom<Value> for i16 {
+ type Error = TryFromIntError;
+
+ fn try_from(value: Value) -> Result<Self, Self::Error> {
+ match value {
+ Value::I8(value) => Ok(value.into()),
+ Value::I16(value) => Ok(value),
+ Value::I32(value) => value.try_into(),
+ Value::I64(value) => value.try_into(),
+ Value::I128(value) => value.try_into(),
+ Value::Isize(value) => value.try_into(),
+ Value::U8(value) => Ok(value.into()),
+ Value::U16(value) => value.try_into(),
+ Value::U32(value) => value.try_into(),
+ Value::U64(value) => value.try_into(),
+ Value::U128(value) => value.try_into(),
+ Value::Usize(value) => value.try_into(),
+ }
+ }
+ }
+
+ impl TryFrom<Value> for i32 {
+ type Error = TryFromIntError;
+
+ fn try_from(value: Value) -> Result<Self, Self::Error> {
+ match value {
+ Value::I8(value) => Ok(value.into()),
+ Value::I16(value) => Ok(value.into()),
+ Value::I32(value) => Ok(value),
+ Value::I64(value) => value.try_into(),
+ Value::I128(value) => value.try_into(),
+ Value::Isize(value) => value.try_into(),
+ Value::U8(value) => Ok(value.into()),
+ Value::U16(value) => Ok(value.into()),
+ Value::U32(value) => value.try_into(),
+ Value::U64(value) => value.try_into(),
+ Value::U128(value) => value.try_into(),
+ Value::Usize(value) => value.try_into(),
+ }
+ }
+ }
+
+ impl TryFrom<Value> for i64 {
+ type Error = TryFromIntError;
+
+ fn try_from(value: Value) -> Result<Self, Self::Error> {
+ match value {
+ Value::I8(value) => Ok(value.into()),
+ Value::I16(value) => Ok(value.into()),
+ Value::I32(value) => Ok(value.into()),
+ Value::I64(value) => Ok(value),
+ Value::I128(value) => value.try_into(),
+ Value::Isize(value) => value.try_into(),
+ Value::U8(value) => Ok(value.into()),
+ Value::U16(value) => Ok(value.into()),
+ Value::U32(value) => Ok(value.into()),
+ Value::U64(value) => value.try_into(),
+ Value::U128(value) => value.try_into(),
+ Value::Usize(value) => value.try_into(),
+ }
+ }
+ }
+
+ impl TryFrom<Value> for i128 {
+ type Error = TryFromIntError;
+
+ fn try_from(value: Value) -> Result<Self, Self::Error> {
+ match value {
+ Value::I8(value) => Ok(value.into()),
+ Value::I16(value) => Ok(value.into()),
+ Value::I32(value) => Ok(value.into()),
+ Value::I64(value) => Ok(value.into()),
+ Value::I128(value) => Ok(value),
+ Value::Isize(value) => value.try_into(),
+ Value::U8(value) => Ok(value.into()),
+ Value::U16(value) => Ok(value.into()),
+ Value::U32(value) => Ok(value.into()),
+ Value::U64(value) => Ok(value.into()),
+ Value::U128(value) => value.try_into(),
+ Value::Usize(value) => value.try_into(),
+ }
+ }
+ }
+
+ impl TryFrom<Value> for isize {
+ type Error = TryFromIntError;
+
+ fn try_from(value: Value) -> Result<Self, Self::Error> {
+ match value {
+ Value::I8(value) => Ok(value.into()),
+ Value::I16(value) => Ok(value.into()),
+ Value::I32(value) => value.try_into(),
+ Value::I64(value) => value.try_into(),
+ Value::I128(value) => value.try_into(),
+ Value::Isize(value) => Ok(value),
+ Value::U8(value) => Ok(value.into()),
+ Value::U16(value) => value.try_into(),
+ Value::U32(value) => value.try_into(),
+ Value::U64(value) => value.try_into(),
+ Value::U128(value) => value.try_into(),
+ Value::Usize(value) => value.try_into(),
+ }
+ }
+ }
+
+ impl TryFrom<Value> for u8 {
+ type Error = TryFromIntError;
+
+ fn try_from(value: Value) -> Result<Self, Self::Error> {
+ match value {
+ Value::U8(value) => Ok(value),
+ Value::U16(value) => value.try_into(),
+ Value::U32(value) => value.try_into(),
+ Value::U64(value) => value.try_into(),
+ Value::U128(value) => value.try_into(),
+ Value::Usize(value) => value.try_into(),
+ Value::I8(value) => value.try_into(),
+ Value::I16(value) => value.try_into(),
+ Value::I32(value) => value.try_into(),
+ Value::I64(value) => value.try_into(),
+ Value::I128(value) => value.try_into(),
+ Value::Isize(value) => value.try_into(),
+ }
+ }
+ }
+
+ impl TryFrom<Value> for u16 {
+ type Error = TryFromIntError;
+
+ fn try_from(value: Value) -> Result<Self, Self::Error> {
+ match value {
+ Value::U8(value) => Ok(value.into()),
+ Value::U16(value) => Ok(value),
+ Value::U32(value) => value.try_into(),
+ Value::U64(value) => value.try_into(),
+ Value::U128(value) => value.try_into(),
+ Value::Usize(value) => value.try_into(),
+ Value::I8(value) => value.try_into(),
+ Value::I16(value) => value.try_into(),
+ Value::I32(value) => value.try_into(),
+ Value::I64(value) => value.try_into(),
+ Value::I128(value) => value.try_into(),
+ Value::Isize(value) => value.try_into(),
+ }
+ }
+ }
+
+ impl TryFrom<Value> for u32 {
+ type Error = TryFromIntError;
+
+ fn try_from(value: Value) -> Result<Self, Self::Error> {
+ match value {
+ Value::U8(value) => Ok(value.into()),
+ Value::U16(value) => Ok(value.into()),
+ Value::U32(value) => Ok(value),
+ Value::U64(value) => value.try_into(),
+ Value::U128(value) => value.try_into(),
+ Value::Usize(value) => value.try_into(),
+ Value::I8(value) => value.try_into(),
+ Value::I16(value) => value.try_into(),
+ Value::I32(value) => value.try_into(),
+ Value::I64(value) => value.try_into(),
+ Value::I128(value) => value.try_into(),
+ Value::Isize(value) => value.try_into(),
+ }
+ }
+ }
+
+ impl TryFrom<Value> for u64 {
+ type Error = TryFromIntError;
+
+ fn try_from(value: Value) -> Result<Self, Self::Error> {
+ match value {
+ Value::U8(value) => Ok(value.into()),
+ Value::U16(value) => Ok(value.into()),
+ Value::U32(value) => Ok(value.into()),
+ Value::U64(value) => Ok(value),
+ Value::U128(value) => value.try_into(),
+ Value::Usize(value) => value.try_into(),
+ Value::I8(value) => value.try_into(),
+ Value::I16(value) => value.try_into(),
+ Value::I32(value) => value.try_into(),
+ Value::I64(value) => value.try_into(),
+ Value::I128(value) => value.try_into(),
+ Value::Isize(value) => value.try_into(),
+ }
+ }
+ }
+
+ impl TryFrom<Value> for u128 {
+ type Error = TryFromIntError;
+
+ fn try_from(value: Value) -> Result<Self, Self::Error> {
+ match value {
+ Value::U8(value) => Ok(value.into()),
+ Value::U16(value) => Ok(value.into()),
+ Value::U32(value) => Ok(value.into()),
+ Value::U64(value) => Ok(value.into()),
+ Value::U128(value) => Ok(value),
+ Value::Usize(value) => value.try_into(),
+ Value::I8(value) => value.try_into(),
+ Value::I16(value) => value.try_into(),
+ Value::I32(value) => value.try_into(),
+ Value::I64(value) => value.try_into(),
+ Value::I128(value) => value.try_into(),
+ Value::Isize(value) => value.try_into(),
+ }
+ }
+ }
+
+ impl TryFrom<Value> for usize {
+ type Error = TryFromIntError;
+
+ fn try_from(value: Value) -> Result<Self, Self::Error> {
+ match value {
+ Value::U8(value) => Ok(value.into()),
+ Value::U16(value) => Ok(value.into()),
+ Value::U32(value) => value.try_into(),
+ Value::U64(value) => value.try_into(),
+ Value::U128(value) => value.try_into(),
+ Value::Usize(value) => Ok(value),
+ Value::I8(value) => value.try_into(),
+ Value::I16(value) => value.try_into(),
+ Value::I32(value) => value.try_into(),
+ Value::I64(value) => value.try_into(),
+ Value::I128(value) => value.try_into(),
+ Value::Isize(value) => value.try_into(),
+ }
+ }
+ }
+}
+
+pub mod optional {
+ use crate::{protocol::Protocol, Walker};
+
+ pub enum Kind {
+ Some,
+ None,
+ }
+
+ pub enum Optional {}
+
+ impl Protocol for Optional {
+ type Hint<'walking, 'ctx: 'walking> = Option<Kind>;
+
+ type Known<'walking, 'ctx: 'walking> = Option<Kind>;
+
+ type Accessor<'walking, 'ctx: 'walking> = Option<&'walking mut dyn Walker<'ctx>>;
+ }
+}
+
+pub mod unit {
+ use crate::protocol::Protocol;
+
+ pub enum Unit {}
+
+ impl Protocol for Unit {
+ type Hint<'walking, 'ctx: 'walking> = ();
+
+ type Known<'walking, 'ctx: 'walking> = ();
+
+ type Accessor<'walking, 'ctx: 'walking> = ();
+ }
+}
+
+pub mod r#struct {
+ use core::any::TypeId;
+
+ use crate::protocol::Protocol;
+
+ pub struct Hint<'walking> {
+ pub name: Option<&'static str>,
+ pub type_name: Option<&'static str>,
+ pub id: Option<TypeId>,
+ pub fields: Option<&'walking [&'walking str]>,
+ }
+
+ pub struct Known<'walking> {
+ pub name: Option<&'static str>,
+ pub type_name: Option<&'static str>,
+ pub id: Option<TypeId>,
+ pub fields: Option<&'walking [&'walking str]>,
+ }
+
+ pub enum Struct {}
+
+ impl Protocol for Struct {
+ type Hint<'walking, 'ctx: 'walking> = Hint<'walking>;
+
+ type Known<'walking, 'ctx: 'walking> = Known<'walking>;
+
+ type Accessor<'walking, 'ctx: 'walking> = &'walking mut dyn super::map::Accessor<'ctx>;
+ }
+}
+
+pub mod r#enum {
+ use core::any::TypeId;
+
+ use crate::{protocol::Protocol, ControlFlow, Visitor};
+
+ pub struct Hint<'walking> {
+ pub name: Option<&'static str>,
+ pub type_name: Option<&'static str>,
+ pub id: Option<TypeId>,
+ pub variants: Option<&'walking [&'walking str]>,
+ }
+
+ pub struct Known<'walking> {
+ pub name: Option<&'static str>,
+ pub type_name: Option<&'static str>,
+ pub id: Option<TypeId>,
+ pub variant: Option<&'walking str>,
+ }
+
+ pub trait Accessor<'ctx> {
+ fn variant(&mut self, visitor: &mut dyn Visitor<'ctx>) -> ControlFlow;
+ fn walk(&mut self, visitor: &mut dyn Visitor<'ctx>) -> ControlFlow;
+ }
+
+ pub enum Enum {}
+
+ impl Protocol for Enum {
+ type Hint<'walking, 'ctx: 'walking> = Hint<'walking>;
+
+ type Known<'walking, 'ctx: 'walking> = Known<'walking>;
+
+ type Accessor<'walking, 'ctx: 'walking> = &'walking mut dyn Accessor<'ctx>;
+ }
+}
+*/