retoor/orchid
1
0
Fork 0
forked from Orchid/orchid
Code Pull Requests 1 Activity

base and extension fully compiles, host in good shape

Browse Source
This commit is contained in:
Lawrence Bethlenfalvy
2025-01-25 00:10:49 +01:00
parent 7be8716b19
commit 2b79e96dc9
49 changed files with 1719 additions and 1168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

224
orchid-api-traits/src/coding.rs
View File

@@ -1,29 +1,38 @@
use std::borrow::Cow;
use std::collections::HashMap;
use std::future::Future;
use std::hash::Hash;
use std::io::{Read, Write};
use std::iter;
use std::num::NonZero;
use std::ops::{Range, RangeInclusive};
use std::pin::Pin;
use std::rc::Rc;
use std::sync::Arc;
use async_std::io::{Read, ReadExt, Write, WriteExt};
use async_stream::stream;
use futures::future::LocalBoxFuture;
use futures::{FutureExt, StreamExt};
use never::Never;
use ordered_float::NotNan;
use crate::encode_enum;
pub trait Decode {
pub trait Decode: 'static {
/// Decode an instance from the beginning of the buffer. Return the decoded
/// data and the remaining buffer.
fn decode<R: Read + ?Sized>(read: &mut R) -> Self;
fn decode<R: Read + ?Sized>(read: Pin<&mut R>) -> impl Future<Output = Self> + '_;
}
pub trait Encode {
/// Append an instance of the struct to the buffer
fn encode<W: Write + ?Sized>(&self, write: &mut W);
fn encode<W: Write + ?Sized>(&self, write: Pin<&mut W>) -> impl Future<Output = ()>;
}
pub trait Coding: Encode + Decode + Clone {
fn get_decoder<T>(map: impl Fn(Self) -> T + 'static) -> impl Fn(&mut dyn Read) -> T {
move |r| map(Self::decode(r))
fn get_decoder<T: 'static, F: Future<Output = T> + 'static>(
map: impl Fn(Self) -> F + Clone + 'static,
) -> impl for<'a> Fn(Pin<&'a mut dyn Read>) -> LocalBoxFuture<'a, T> {
move |r| {
let map = map.clone();
async move { map(Self::decode(r).await).await }.boxed_local()
}
}
}
impl<T: Encode + Decode + Clone> Coding for T {}
@@ -31,15 +40,15 @@ impl<T: Encode + Decode + Clone> Coding for T {}
macro_rules! num_impl {
($number:ty) => {
impl Decode for $number {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
let mut bytes = [0u8; (<$number>::BITS / 8) as usize];
read.read_exact(&mut bytes).unwrap();
read.read_exact(&mut bytes).await.unwrap();
<$number>::from_be_bytes(bytes)
}
}
impl Encode for $number {
fn encode<W: Write + ?Sized>(&self, write: &mut W) {
write.write_all(&self.to_be_bytes()).expect("Could not write number")
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
write.write_all(&self.to_be_bytes()).await.expect("Could not write number")
}
}
};
@@ -57,41 +66,45 @@ num_impl!(i8);
macro_rules! nonzero_impl {
($name:ty) => {
impl Decode for $name {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self { Self::new(Decode::decode(read)).unwrap() }
impl Decode for NonZero<$name> {
async fn decode<R: Read + ?Sized>(read: Pin<&mut R>) -> Self {
Self::new(<$name as Decode>::decode(read).await).unwrap()
}
}
impl Encode for $name {
fn encode<W: Write + ?Sized>(&self, write: &mut W) { self.get().encode(write) }
impl Encode for NonZero<$name> {
async fn encode<W: Write + ?Sized>(&self, write: Pin<&mut W>) {
self.get().encode(write).await
}
}
};
}
nonzero_impl!(std::num::NonZeroU8);
nonzero_impl!(std::num::NonZeroU16);
nonzero_impl!(std::num::NonZeroU32);
nonzero_impl!(std::num::NonZeroU64);
nonzero_impl!(std::num::NonZeroU128);
nonzero_impl!(std::num::NonZeroI8);
nonzero_impl!(std::num::NonZeroI16);
nonzero_impl!(std::num::NonZeroI32);
nonzero_impl!(std::num::NonZeroI64);
nonzero_impl!(std::num::NonZeroI128);
nonzero_impl!(u8);
nonzero_impl!(u16);
nonzero_impl!(u32);
nonzero_impl!(u64);
nonzero_impl!(u128);
nonzero_impl!(i8);
nonzero_impl!(i16);
nonzero_impl!(i32);
nonzero_impl!(i64);
nonzero_impl!(i128);
impl<T: Encode + ?Sized> Encode for &T {
fn encode<W: Write + ?Sized>(&self, write: &mut W) { (**self).encode(write) }
async fn encode<W: Write + ?Sized>(&self, write: Pin<&mut W>) { (**self).encode(write).await }
}
macro_rules! float_impl {
($t:ty, $size:expr) => {
impl Decode for NotNan<$t> {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
let mut bytes = [0u8; $size];
read.read_exact(&mut bytes).unwrap();
read.read_exact(&mut bytes).await.unwrap();
NotNan::new(<$t>::from_be_bytes(bytes)).expect("Float was NaN")
}
}
impl Encode for NotNan<$t> {
fn encode<W: Write + ?Sized>(&self, write: &mut W) {
write.write_all(&self.as_ref().to_be_bytes()).expect("Could not write number")
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
write.write_all(&self.as_ref().to_be_bytes()).await.expect("Could not write number")
}
}
};
@@ -101,98 +114,103 @@ float_impl!(f64, 8);
float_impl!(f32, 4);
impl Decode for String {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self {
let len = u64::decode(read).try_into().unwrap();
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
let len = u64::decode(read.as_mut()).await.try_into().unwrap();
let mut data = vec![0u8; len];
read.read_exact(&mut data).unwrap();
read.read_exact(&mut data).await.unwrap();
std::str::from_utf8(&data).expect("String invalid UTF-8").to_owned()
}
}
impl Encode for String {
fn encode<W: Write + ?Sized>(&self, write: &mut W) {
u64::try_from(self.len()).unwrap().encode(write);
write.write_all(self.as_bytes()).unwrap()
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
u64::try_from(self.len()).unwrap().encode(write.as_mut()).await;
write.write_all(self.as_bytes()).await.unwrap()
}
}
impl Encode for str {
fn encode<W: Write + ?Sized>(&self, write: &mut W) {
u64::try_from(self.len()).unwrap().encode(write);
write.write_all(self.as_bytes()).unwrap()
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
u64::try_from(self.len()).unwrap().encode(write.as_mut()).await;
write.write_all(self.as_bytes()).await.unwrap()
}
}
impl<T: Decode> Decode for Vec<T> {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self {
let len = u64::decode(read).try_into().unwrap();
iter::repeat_with(|| T::decode(read)).take(len).collect()
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
let len = u64::decode(read.as_mut()).await.try_into().unwrap();
stream! { loop { yield T::decode(read.as_mut()).await } }.take(len).collect().await
}
}
impl<T: Encode> Encode for Vec<T> {
fn encode<W: Write + ?Sized>(&self, write: &mut W) {
u64::try_from(self.len()).unwrap().encode(write);
self.iter().for_each(|t| t.encode(write));
async fn encode<W: Write + ?Sized>(&self, write: Pin<&mut W>) {
self.as_slice().encode(write).await
}
}
impl<T: Encode> Encode for [T] {
fn encode<W: Write + ?Sized>(&self, write: &mut W) {
u64::try_from(self.len()).unwrap().encode(write);
self.iter().for_each(|t| t.encode(write));
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
u64::try_from(self.len()).unwrap().encode(write.as_mut()).await;
for t in self.iter() {
t.encode(write.as_mut()).await
}
}
}
impl<T: Decode> Decode for Option<T> {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self {
match u8::decode(read) {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
match u8::decode(read.as_mut()).await {
0 => None,
1 => Some(T::decode(read)),
1 => Some(T::decode(read).await),
x => panic!("{x} is not a valid option value"),
}
}
}
impl<T: Encode> Encode for Option<T> {
fn encode<W: Write + ?Sized>(&self, write: &mut W) {
let t = if let Some(t) = self { t } else { return 0u8.encode(write) };
1u8.encode(write);
t.encode(write);
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
let t = if let Some(t) = self { t } else { return 0u8.encode(write.as_mut()).await };
1u8.encode(write.as_mut()).await;
t.encode(write).await;
}
}
impl<T: Decode, E: Decode> Decode for Result<T, E> {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self {
match u8::decode(read) {
0 => Self::Ok(T::decode(read)),
1 => Self::Err(E::decode(read)),
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
match u8::decode(read.as_mut()).await {
0 => Self::Ok(T::decode(read).await),
1 => Self::Err(E::decode(read).await),
x => panic!("Invalid Result tag {x}"),
}
}
}
impl<T: Encode, E: Encode> Encode for Result<T, E> {
fn encode<W: Write + ?Sized>(&self, write: &mut W) {
async fn encode<W: Write + ?Sized>(&self, write: Pin<&mut W>) {
match self {
Ok(t) => encode_enum(write, 0, |w| t.encode(w)),
Err(e) => encode_enum(write, 1, |w| e.encode(w)),
Ok(t) => encode_enum(write, 0, |w| t.encode(w)).await,
Err(e) => encode_enum(write, 1, |w| e.encode(w)).await,
}
}
}
impl<K: Decode + Eq + Hash, V: Decode> Decode for HashMap<K, V> {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self {
let len = u64::decode(read).try_into().unwrap();
iter::repeat_with(|| <(K, V)>::decode(read)).take(len).collect()
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
let len = u64::decode(read.as_mut()).await.try_into().unwrap();
stream! { loop { yield <(K, V)>::decode(read.as_mut()).await } }.take(len).collect().await
}
}
impl<K: Encode + Eq + Hash, V: Encode> Encode for HashMap<K, V> {
fn encode<W: Write + ?Sized>(&self, write: &mut W) {
u64::try_from(self.len()).unwrap().encode(write);
self.iter().for_each(|pair| pair.encode(write));
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
u64::try_from(self.len()).unwrap().encode(write.as_mut()).await;
for pair in self.iter() {
pair.encode(write.as_mut()).await
}
}
}
macro_rules! tuple {
(($($t:ident)*) ($($T:ident)*)) => {
impl<$($T: Decode),*> Decode for ($($T,)*) {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self { ($($T::decode(read),)*) }
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
($($T::decode(read.as_mut()).await,)*)
}
}
impl<$($T: Encode),*> Encode for ($($T,)*) {
fn encode<W: Write + ?Sized>(&self, write: &mut W) {
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
let ($($t,)*) = self;
$( $t.encode(write); )*
$( $t.encode(write.as_mut()).await; )*
}
}
};
@@ -216,52 +234,59 @@ tuple!((t u v x y z a b c d e f g h i) (T U V X Y Z A B C D E F G H I));
tuple!((t u v x y z a b c d e f g h i j) (T U V X Y Z A B C D E F G H I J)); // 16
impl Decode for () {
fn decode<R: Read + ?Sized>(_: &mut R) -> Self {}
async fn decode<R: Read + ?Sized>(_: Pin<&mut R>) -> Self {}
}
impl Encode for () {
fn encode<W: Write + ?Sized>(&self, _: &mut W) {}
async fn encode<W: Write + ?Sized>(&self, _: Pin<&mut W>) {}
}
impl Decode for Never {
fn decode<R: Read + ?Sized>(_: &mut R) -> Self {
async fn decode<R: Read + ?Sized>(_: Pin<&mut R>) -> Self {
unreachable!("A value of Never cannot exist so it can't have been serialized");
}
}
impl Encode for Never {
fn encode<W: Write + ?Sized>(&self, _: &mut W) { match *self {} }
async fn encode<W: Write + ?Sized>(&self, _: Pin<&mut W>) { match *self {} }
}
impl Decode for bool {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
let mut buf = [0];
read.read_exact(&mut buf).unwrap();
read.read_exact(&mut buf).await.unwrap();
buf[0] != 0
}
}
impl Encode for bool {
fn encode<W: Write + ?Sized>(&self, write: &mut W) {
write.write_all(&[if *self { 0xff } else { 0 }]).unwrap()
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
write.write_all(&[if *self { 0xffu8 } else { 0u8 }]).await.unwrap()
}
}
impl<T: Decode, const N: usize> Decode for [T; N] {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
// TODO: figure out how to do this in safe rust on the stack
((0..N).map(|_| T::decode(read)).collect::<Vec<_>>().try_into())
.unwrap_or_else(|_| unreachable!("The length of this iterator is statically known"))
let v =
stream! { loop { yield T::decode(read.as_mut()).await } }.take(N).collect::<Vec<_>>().await;
v.try_into().unwrap_or_else(|_| unreachable!("The length of this stream is statically known"))
}
}
impl<T: Encode, const N: usize> Encode for [T; N] {
fn encode<W: Write + ?Sized>(&self, write: &mut W) { self.iter().for_each(|t| t.encode(write)) }
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
for t in self.iter() {
t.encode(write.as_mut()).await
}
}
}
macro_rules! two_end_range {
($this:ident, $name:tt, $op:tt, $start:expr, $end:expr) => {
impl<T: Decode> Decode for $name<T> {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self { T::decode(read) $op T::decode(read) }
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
T::decode(read.as_mut()).await $op T::decode(read).await
}
}
impl<T: Encode> Encode for $name<T> {
fn encode<W: Write + ?Sized>(&self, write: &mut W) {
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
let $this = self;
($start).encode(write);
($end).encode(write);
($start).encode(write.as_mut()).await;
($end).encode(write).await;
}
}
}
@@ -273,10 +298,12 @@ two_end_range!(x, RangeInclusive, ..=, x.start(), x.end());
macro_rules! smart_ptr {
($name:tt) => {
impl<T: Decode> Decode for $name<T> {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self { $name::new(T::decode(read)) }
async fn decode<R: Read + ?Sized>(read: Pin<&mut R>) -> Self {
$name::new(T::decode(read).await)
}
}
impl<T: Encode> Encode for $name<T> {
fn encode<W: Write + ?Sized>(&self, write: &mut W) { (**self).encode(write) }
async fn encode<W: Write + ?Sized>(&self, write: Pin<&mut W>) { (**self).encode(write).await }
}
};
}
@@ -285,18 +312,13 @@ smart_ptr!(Arc);
smart_ptr!(Rc);
smart_ptr!(Box);
impl<T: ?Sized + ToOwned> Decode for Cow<'_, T>
where T::Owned: Decode
{
fn decode<R: Read + ?Sized>(read: &mut R) -> Self { Cow::Owned(T::Owned::decode(read)) }
}
impl<T: ?Sized + Encode + ToOwned> Encode for Cow<'_, T> {
fn encode<W: Write + ?Sized>(&self, write: &mut W) { (**self).encode(write) }
}
impl Decode for char {
fn decode<R: Read + ?Sized>(read: &mut R) -> Self { char::from_u32(u32::decode(read)).unwrap() }
async fn decode<R: Read + ?Sized>(read: Pin<&mut R>) -> Self {
char::from_u32(u32::decode(read).await).unwrap()
}
}
impl Encode for char {
fn encode<W: Write + ?Sized>(&self, write: &mut W) { (*self as u32).encode(write) }
async fn encode<W: Write + ?Sized>(&self, write: Pin<&mut W>) {
(*self as u32).encode(write).await
}
}

26
orchid-api-traits/src/helpers.rs
View File

@@ -1,16 +1,22 @@
use std::io::{Read, Write};
use std::future::Future;
use std::pin::Pin;
use async_std::io::{Read, ReadExt, Write, WriteExt};
use itertools::{Chunk, Itertools};
use crate::Encode;
pub fn encode_enum<W: Write + ?Sized>(write: &mut W, id: u8, f: impl FnOnce(&mut W)) {
id.encode(write);
f(write)
pub async fn encode_enum<'a, W: Write + ?Sized, F: Future<Output = ()>>(
mut write: Pin<&'a mut W>,
id: u8,
f: impl FnOnce(Pin<&'a mut W>) -> F,
) {
id.encode(write.as_mut()).await;
f(write).await
}
pub fn write_exact<W: Write + ?Sized>(write: &mut W, bytes: &'static [u8]) {
write.write_all(bytes).expect("Failed to write exact bytes")
pub async fn write_exact<W: Write + ?Sized>(mut write: Pin<&mut W>, bytes: &'static [u8]) {
write.write_all(bytes).await.expect("Failed to write exact bytes")
}
pub fn print_bytes(b: &[u8]) -> String {
@@ -21,16 +27,16 @@ pub fn print_bytes(b: &[u8]) -> String {
.join(" ")
}
pub fn read_exact<R: Read + ?Sized>(read: &mut R, bytes: &'static [u8]) {
pub async fn read_exact<R: Read + ?Sized>(mut read: Pin<&mut R>, bytes: &'static [u8]) {
let mut data = vec![0u8; bytes.len()];
read.read_exact(&mut data).expect("Failed to read bytes");
read.read_exact(&mut data).await.expect("Failed to read bytes");
if data != bytes {
panic!("Wrong bytes!\nExpected: {}\nFound: {}", print_bytes(bytes), print_bytes(&data));
}
}
pub fn enc_vec(enc: &impl Encode) -> Vec<u8> {
pub async fn enc_vec(enc: &impl Encode) -> Vec<u8> {
let mut vec = Vec::new();
enc.encode(&mut vec);
enc.encode(Pin::new(&mut vec)).await;
vec
}

11
orchid-api-traits/src/relations.rs
View File

@@ -1,3 +1,5 @@
use std::future::Future;
use super::coding::Coding;
use crate::helpers::enc_vec;
@@ -5,9 +7,12 @@ pub trait Request: Coding + Sized + Send + 'static {
type Response: Coding + Send + 'static;
}
pub fn respond<R: Request>(_: &R, rep: R::Response) -> Vec<u8> { enc_vec(&rep) }
pub fn respond_with<R: Request>(r: &R, f: impl FnOnce(&R) -> R::Response) -> Vec<u8> {
respond(r, f(r))
pub async fn respond<R: Request>(_: &R, rep: R::Response) -> Vec<u8> { enc_vec(&rep).await }
pub async fn respond_with<R: Request, F: Future<Output = R::Response>>(
r: &R,
f: impl FnOnce(&R) -> F,
) -> Vec<u8> {
respond(r, f(r).await).await
}
pub trait Channel: 'static {