Orchid/orchid
1
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

updated all deps

Browse Source 
migrated away from paste and async-std
This commit is contained in:
Lawrence Bethlenfalvy
2025-09-03 18:42:54 +02:00
parent 7031f3a7d8
commit 088cb6a247
44 changed files with 569 additions and 456 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
orchid-api-traits/Cargo.toml
View File

@@ -6,9 +6,8 @@ edition = "2024"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
async-std = "1.13.0"
async-stream = "0.3.6"
futures = "0.3.31"
futures = { version = "0.3.31", features = ["std"] }
itertools = "0.14.0"
never = "0.1.0"
ordered-float = "5.0.0"

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

@@ -7,9 +7,8 @@ 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::StreamExt;
use futures::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, StreamExt};
use never::Never;
use ordered_float::NotNan;
@@ -18,16 +17,16 @@ use crate::encode_enum;
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: Pin<&mut R>) -> impl Future<Output = Self> + '_;
fn decode<R: AsyncRead + ?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: Pin<&mut W>) -> impl Future<Output = ()>;
fn encode<W: AsyncWrite + ?Sized>(&self, write: Pin<&mut W>) -> impl Future<Output = ()>;
}
pub trait Coding: Encode + Decode + Clone {
fn get_decoder<T: 'static, F: Future<Output = T> + 'static>(
map: impl Fn(Self) -> F + Clone + 'static,
) -> impl AsyncFn(Pin<&mut dyn Read>) -> T {
) -> impl AsyncFn(Pin<&mut dyn AsyncRead>) -> T {
async move |r| map(Self::decode(r).await).await
}
}
@@ -36,14 +35,14 @@ impl<T: Encode + Decode + Clone> Coding for T {}
macro_rules! num_impl {
($number:ty) => {
impl Decode for $number {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?Sized>(mut read: Pin<&mut R>) -> Self {
let mut bytes = [0u8; (<$number>::BITS / 8) as usize];
read.read_exact(&mut bytes).await.unwrap();
<$number>::from_be_bytes(bytes)
}
}
impl Encode for $number {
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?Sized>(&self, mut write: Pin<&mut W>) {
write.write_all(&self.to_be_bytes()).await.expect("Could not write number")
}
}
@@ -63,12 +62,12 @@ num_impl!(i8);
macro_rules! nonzero_impl {
($name:ty) => {
impl Decode for NonZero<$name> {
async fn decode<R: Read + ?Sized>(read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?Sized>(read: Pin<&mut R>) -> Self {
Self::new(<$name as Decode>::decode(read).await).unwrap()
}
}
impl Encode for NonZero<$name> {
async fn encode<W: Write + ?Sized>(&self, write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?Sized>(&self, write: Pin<&mut W>) {
self.get().encode(write).await
}
}
@@ -87,19 +86,21 @@ nonzero_impl!(i64);
nonzero_impl!(i128);
impl<T: Encode + ?Sized> Encode for &T {
async fn encode<W: Write + ?Sized>(&self, write: Pin<&mut W>) { (**self).encode(write).await }
async fn encode<W: AsyncWrite + ?Sized>(&self, write: Pin<&mut W>) {
(**self).encode(write).await
}
}
macro_rules! float_impl {
($t:ty, $size:expr) => {
impl Decode for NotNan<$t> {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?Sized>(mut read: Pin<&mut R>) -> Self {
let mut bytes = [0u8; $size];
read.read_exact(&mut bytes).await.unwrap();
NotNan::new(<$t>::from_be_bytes(bytes)).expect("Float was NaN")
}
}
impl Encode for NotNan<$t> {
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?Sized>(&self, mut write: Pin<&mut W>) {
write.write_all(&self.as_ref().to_be_bytes()).await.expect("Could not write number")
}
}
@@ -110,7 +111,7 @@ float_impl!(f64, 8);
float_impl!(f32, 4);
impl Decode for String {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?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).await.unwrap();
@@ -118,30 +119,30 @@ impl Decode for String {
}
}
impl Encode for String {
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?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 {
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?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> {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?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> {
async fn encode<W: Write + ?Sized>(&self, write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?Sized>(&self, write: Pin<&mut W>) {
self.as_slice().encode(write).await
}
}
impl<T: Encode> Encode for [T] {
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?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
@@ -149,7 +150,7 @@ impl<T: Encode> Encode for [T] {
}
}
impl<T: Decode> Decode for Option<T> {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?Sized>(mut read: Pin<&mut R>) -> Self {
match u8::decode(read.as_mut()).await {
0 => None,
1 => Some(T::decode(read).await),
@@ -158,14 +159,14 @@ impl<T: Decode> Decode for Option<T> {
}
}
impl<T: Encode> Encode for Option<T> {
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?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> {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?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),
@@ -175,7 +176,7 @@ impl<T: Decode, E: Decode> Decode for Result<T, E> {
}
impl<T: Encode, E: Encode> Encode for Result<T, E> {
async fn encode<W: Write + ?Sized>(&self, write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?Sized>(&self, write: Pin<&mut W>) {
match self {
Ok(t) => encode_enum(write, 0, |w| t.encode(w)).await,
Err(e) => encode_enum(write, 1, |w| e.encode(w)).await,
@@ -183,13 +184,13 @@ impl<T: Encode, E: Encode> Encode for Result<T, E> {
}
}
impl<K: Decode + Eq + Hash, V: Decode> Decode for HashMap<K, V> {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?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> {
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?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
@@ -199,12 +200,12 @@ impl<K: Encode + Eq + Hash, V: Encode> Encode for HashMap<K, V> {
macro_rules! tuple {
(($($t:ident)*) ($($T:ident)*)) => {
impl<$($T: Decode),*> Decode for ($($T,)*) {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?Sized>(mut read: Pin<&mut R>) -> Self {
($($T::decode(read.as_mut()).await,)*)
}
}
impl<$($T: Encode),*> Encode for ($($T,)*) {
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?Sized>(&self, mut write: Pin<&mut W>) {
let ($($t,)*) = self;
$( $t.encode(write.as_mut()).await; )*
}
@@ -230,33 +231,33 @@ 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 () {
async fn decode<R: Read + ?Sized>(_: Pin<&mut R>) -> Self {}
async fn decode<R: AsyncRead + ?Sized>(_: Pin<&mut R>) -> Self {}
}
impl Encode for () {
async fn encode<W: Write + ?Sized>(&self, _: Pin<&mut W>) {}
async fn encode<W: AsyncWrite + ?Sized>(&self, _: Pin<&mut W>) {}
}
impl Decode for Never {
async fn decode<R: Read + ?Sized>(_: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?Sized>(_: Pin<&mut R>) -> Self {
unreachable!("A value of Never cannot exist so it can't have been serialized");
}
}
impl Encode for Never {
async fn encode<W: Write + ?Sized>(&self, _: Pin<&mut W>) { match *self {} }
async fn encode<W: AsyncWrite + ?Sized>(&self, _: Pin<&mut W>) { match *self {} }
}
impl Decode for bool {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?Sized>(mut read: Pin<&mut R>) -> Self {
let mut buf = [0];
read.read_exact(&mut buf).await.unwrap();
buf[0] != 0
}
}
impl Encode for bool {
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?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] {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?Sized>(mut read: Pin<&mut R>) -> Self {
// TODO: figure out how to do this in safe rust on the stack
let v =
stream! { loop { yield T::decode(read.as_mut()).await } }.take(N).collect::<Vec<_>>().await;
@@ -264,7 +265,7 @@ impl<T: Decode, const N: usize> Decode for [T; N] {
}
}
impl<T: Encode, const N: usize> Encode for [T; N] {
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?Sized>(&self, mut write: Pin<&mut W>) {
for t in self.iter() {
t.encode(write.as_mut()).await
}
@@ -274,12 +275,12 @@ impl<T: Encode, const N: usize> Encode for [T; N] {
macro_rules! two_end_range {
($this:ident, $name:tt, $op:tt, $start:expr, $end:expr) => {
impl<T: Decode> Decode for $name<T> {
async fn decode<R: Read + ?Sized>(mut read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?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> {
async fn encode<W: Write + ?Sized>(&self, mut write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?Sized>(&self, mut write: Pin<&mut W>) {
let $this = self;
($start).encode(write.as_mut()).await;
($end).encode(write).await;
@@ -294,12 +295,14 @@ two_end_range!(x, RangeInclusive, ..=, x.start(), x.end());
macro_rules! smart_ptr {
($name:tt) => {
impl<T: Decode> Decode for $name<T> {
async fn decode<R: Read + ?Sized>(read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?Sized>(read: Pin<&mut R>) -> Self {
$name::new(T::decode(read).await)
}
}
impl<T: Encode> Encode for $name<T> {
async fn encode<W: Write + ?Sized>(&self, write: Pin<&mut W>) { (**self).encode(write).await }
async fn encode<W: AsyncWrite + ?Sized>(&self, write: Pin<&mut W>) {
(**self).encode(write).await
}
}
};
}
@@ -309,12 +312,12 @@ smart_ptr!(Rc);
smart_ptr!(Box);
impl Decode for char {
async fn decode<R: Read + ?Sized>(read: Pin<&mut R>) -> Self {
async fn decode<R: AsyncRead + ?Sized>(read: Pin<&mut R>) -> Self {
char::from_u32(u32::decode(read).await).unwrap()
}
}
impl Encode for char {
async fn encode<W: Write + ?Sized>(&self, write: Pin<&mut W>) {
async fn encode<W: AsyncWrite + ?Sized>(&self, write: Pin<&mut W>) {
(*self as u32).encode(write).await
}
}

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

@@ -1,12 +1,12 @@
use std::future::Future;
use std::pin::Pin;
use async_std::io::{Read, ReadExt, Write, WriteExt};
use futures::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
use itertools::{Chunk, Itertools};
use crate::Encode;
pub async fn encode_enum<'a, W: Write + ?Sized, F: Future<Output = ()>>(
pub async fn encode_enum<'a, W: AsyncWrite + ?Sized, F: Future<Output = ()>>(
mut write: Pin<&'a mut W>,
id: u8,
f: impl FnOnce(Pin<&'a mut W>) -> F,
@@ -15,7 +15,7 @@ pub async fn encode_enum<'a, W: Write + ?Sized, F: Future<Output = ()>>(
f(write).await
}
pub async fn write_exact<W: Write + ?Sized>(mut write: Pin<&mut W>, bytes: &'static [u8]) {
pub async fn write_exact<W: AsyncWrite + ?Sized>(mut write: Pin<&mut W>, bytes: &'static [u8]) {
write.write_all(bytes).await.expect("Failed to write exact bytes")
}
@@ -27,7 +27,7 @@ pub fn print_bytes(b: &[u8]) -> String {
.join(" ")
}
pub async fn read_exact<R: Read + ?Sized>(mut read: Pin<&mut R>, bytes: &'static [u8]) {
pub async fn read_exact<R: AsyncRead + ?Sized>(mut read: Pin<&mut R>, bytes: &'static [u8]) {
let mut data = vec![0u8; bytes.len()];
read.read_exact(&mut data).await.expect("Failed to read bytes");
if data != bytes {

2
orchid-api-traits/src/lib.rs
View File

@@ -3,8 +3,8 @@ mod helpers;
mod hierarchy;
mod relations;
pub use async_std;
pub use coding::*;
pub use futures::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
pub use helpers::*;
pub use hierarchy::*;
pub use relations::*;