-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::{Implementer, Protocol};

-

- use super::{hint::HintObject, ControlFlow};

-

- pub trait Accessor<'ctx> {

- 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 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 sequence {

- use crate::protocol::{Implementer, Protocol};

-

- #[derive(PartialEq)]

- 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 {

- pub min_len: Option<usize>,

- pub max_len: Option<usize>,

- }

-

- pub struct Known {

- pub len: Option<usize>,

- }

-

- pub trait Accessor<'ctx> {

- fn next_key(&mut self, visitor: &mut dyn Visitor<'ctx>) -> ControlFlow;

- fn value(&mut self, visitor: &mut dyn Visitor<'ctx>) -> ControlFlow;

- }

-

- pub enum Map {}

-

- impl Protocol for Map {

- type Hint<'walking, 'ctx: 'walking> = Hint;

-

- type Known<'walking, 'ctx: 'walking> = Known;

-

- type Accessor<'walking, 'ctx: 'walking> = &'walking mut dyn Accessor<'ctx>;

- }

-}

-

-pub mod reference {

- use core::{any::Any, marker::PhantomData};

-

- use crate::protocol::Protocol;

-

- pub enum Kind {

- Walking,

- Context,

- Static,

- }

-

- pub struct Hint {

- pub kind: Option<Kind>,

-

- pub min_len: Option<usize>,

- pub max_len: Option<usize>,

- }

-

- pub struct Known {

- pub kind: Option<Kind>,

-

- /// For dynamically sized types.

- pub len: Option<usize>,

- }

-

- pub enum Ref<'walking, 'ctx, T: ?Sized + Any> {

- Walking(&'walking T),

- Context(&'ctx T),

- Static(&'static T),

- }

-

- pub enum Mut<'walking, 'ctx, T: ?Sized + Any> {

- Walking(&'walking mut T),

- Context(&'ctx mut T),

- Static(&'static mut T),

- }

-

- pub struct Reference<T: ?Sized + Any>(PhantomData<fn() -> T>);

-

- pub struct ReferenceMut<T: ?Sized + Any>(PhantomData<fn() -> T>);

-

- impl<T: ?Sized + Any> Protocol for Reference<T> {

- type Hint<'walking, 'ctx: 'walking> = Hint;

-

- 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<'walking, 'ctx: 'walking> = Hint;

-

- 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>;

- }

-}

-*/