redesign u24.

Author: jjeffcaii

rsocket-messaging/src/builder.rs

@@ -0,0 +1,48 @@
+use super::requester::Requester;
+use rsocket_rust::extension::MimeType;
+
+pub struct RequesterBuilder {
+    data_mime_type: MimeType,
+    route: Option<String>,
+    data: Option<Vec<u8>>,
+}
+
+impl Default for RequesterBuilder {
+    fn default() -> Self {
+        Self {
+            data_mime_type: MimeType::APPLICATION_JSON,
+            route: None,
+            data: None,
+        }
+    }
+}
+
+impl RequesterBuilder {
+    pub fn data_mime_type<I>(mut self, mime_type: I) -> Self
+    where
+        I: Into<MimeType>,
+    {
+        self.data_mime_type = mime_type.into();
+        self
+    }
+
+    pub fn setup_route<I>(mut self, route: I) -> Self
+    where
+        I: Into<String>,
+    {
+        self.route = Some(route.into());
+        self
+    }
+
+    pub fn setup_data<D>(mut self, data: D) -> Self
+    where
+        D: Into<Vec<u8>>,
+    {
+        self.data = Some(data.into());
+        self
+    }
+
+    pub fn build(self) -> Requester {
+        todo!("build requester")
+    }
+}

rsocket-messaging/src/lib.rs

@@ -1,4 +1,6 @@
+mod builder;
 mod misc;
 mod requester;
 
-pub use requester::{RequestSpec, Requester, RequesterBuilder};
+pub use builder::RequesterBuilder;
+pub use requester::{RequestSpec, Requester};

rsocket-messaging/src/misc.rs

@@ -1,5 +1,5 @@
 use bytes::{BufMut, BytesMut};
-use rsocket_rust::extension::{MimeType, MIME_APPLICATION_CBOR, MIME_APPLICATION_JSON};
+use rsocket_rust::extension::MimeType;
 use serde::{Deserialize, Serialize};
 use std::error::Error;
 
@@ -8,8 +8,8 @@ where
     T: Deserialize<'a>,
 {
     match *mime_type {
-        MIME_APPLICATION_JSON => Ok(serde_json::from_slice(raw)?),
-        MIME_APPLICATION_CBOR => Ok(serde_cbor::from_slice(raw)?),
+        MimeType::APPLICATION_JSON => Ok(serde_json::from_slice(raw)?),
+        MimeType::APPLICATION_CBOR => Ok(serde_cbor::from_slice(raw)?),
         _ => panic!(""),
     }
 }
@@ -23,12 +23,12 @@ where
     T: Sized + Serialize,
 {
     match *mime_type {
-        MIME_APPLICATION_JSON => {
+        MimeType::APPLICATION_JSON => {
             let raw = serde_json::to_vec(data)?;
             bf.put_slice(&raw[..]);
             Ok(())
         }
-        MIME_APPLICATION_CBOR => {
+        MimeType::APPLICATION_CBOR => {
             let raw = serde_cbor::to_vec(data)?;
             bf.put_slice(&raw[..]);
             Ok(())

rsocket-messaging/src/requester.rs

@@ -1,115 +1,51 @@
 use super::misc::{marshal, unmarshal};
 use bytes::BytesMut;
 use rsocket_rust::error::RSocketError;
-use rsocket_rust::extension::{
-    CompositeMetadata, MimeType, RoutingMetadata, MIME_APPLICATION_JSON,
-    MIME_MESSAGE_X_RSOCKET_ROUTING_V0,
-};
+use rsocket_rust::extension::{CompositeMetadata, MimeType, RoutingMetadata};
 use rsocket_rust::prelude::*;
 use rsocket_rust::utils::Writeable;
 use serde::{Deserialize, Serialize};
 use std::collections::LinkedList;
 use std::error::Error;
+use std::sync::Arc;
 
-pub struct RequesterBuilder {
-    data_mime_type: MimeType,
-    route: Option<String>,
-    data: Option<Vec<u8>>,
-}
-
-impl Default for RequesterBuilder {
-    fn default() -> Self {
-        Self {
-            data_mime_type: MIME_APPLICATION_JSON,
-            route: None,
-            data: None,
-        }
-    }
-}
-
-impl RequesterBuilder {
-    pub fn data_mime_type<I>(mut self, mime_type: I) -> Self
-    where
-        I: Into<MimeType>,
-    {
-        self.data_mime_type = mime_type.into();
-        self
-    }
-
-    pub fn setup_route<I>(mut self, route: I) -> Self
-    where
-        I: Into<String>,
-    {
-        self.route = Some(route.into());
-        self
-    }
-
-    pub fn setup_data<D>(mut self, data: D) -> Self
-    where
-        D: Into<Vec<u8>>,
-    {
-        self.data = Some(data.into());
-        self
-    }
-
-    pub fn build<S>(self) -> Requester<S>
-    where
-        S: RSocket + Clone,
-    {
-        todo!("build requester")
-    }
+pub struct Requester {
+    rsocket: Arc<Box<dyn RSocket>>,
 }
 
-pub struct Requester<S>
-where
-    S: RSocket + Clone,
-{
-    rsocket: S,
-}
-
-pub struct RequestSpec<S>
-where
-    S: RSocket + Clone,
-{
+pub struct RequestSpec {
     data: Option<Vec<u8>>,
-    rsocket: S,
+    rsocket: Arc<Box<dyn RSocket>>,
     data_mime_type: MimeType,
     metadatas: LinkedList<(MimeType, Vec<u8>)>,
 }
 
-impl<S> From<S> for Requester<S>
-where
-    S: RSocket + Clone,
-{
-    fn from(rsocket: S) -> Requester<S> {
-        Requester { rsocket }
+impl From<Box<dyn RSocket>> for Requester {
+    fn from(rsocket: Box<dyn RSocket>) -> Requester {
+        Requester {
+            rsocket: Arc::new(rsocket),
+        }
     }
 }
 
-impl<C> Requester<C>
-where
-    C: RSocket + Clone,
-{
-    pub fn route(&self, route: &str) -> RequestSpec<C> {
+impl Requester {
+    pub fn route(&self, route: &str) -> RequestSpec {
         let routing = RoutingMetadata::builder().push_str(route).build();
         let mut buf = BytesMut::new();
         routing.write_to(&mut buf);
 
         let mut metadatas: LinkedList<(MimeType, Vec<u8>)> = Default::default();
-        metadatas.push_back((MIME_MESSAGE_X_RSOCKET_ROUTING_V0, buf.to_vec()));
+        metadatas.push_back((MimeType::MESSAGE_X_RSOCKET_ROUTING_V0, buf.to_vec()));
         RequestSpec {
             data: None,
             rsocket: self.rsocket.clone(),
-            data_mime_type: MIME_APPLICATION_JSON,
+            data_mime_type: MimeType::APPLICATION_JSON,
             metadatas,
         }
     }
 }
 
-impl<C> RequestSpec<C>
-where
-    C: RSocket + Clone,
-{
+impl RequestSpec {
     pub fn metadata<T, M>(&mut self, metadata: &T, mime_type: M) -> Result<(), Box<dyn Error>>
     where
         T: Sized + Serialize,
@@ -160,7 +96,7 @@ where
     }
 
     #[inline]
-    fn preflight(self) -> (Payload, MimeType, C) {
+    fn preflight(self) -> (Payload, MimeType, Arc<Box<dyn RSocket>>) {
         let mut b = BytesMut::new();
         let mut c = CompositeMetadata::builder();
         for (mime_type, raw) in self.metadatas.into_iter() {

rsocket-test/tests/test_composite_metadata.rs

@@ -6,7 +6,10 @@ use rsocket_rust::utils::Writeable;
 fn encode_and_decode_composite_metadata() {
     let bingo = |metadatas: Vec<&CompositeMetadataEntry>| {
         assert_eq!(2, metadatas.len());
-        assert_eq!(extension::MIME_TEXT_PLAIN, *metadatas[0].get_mime_type());
+        assert_eq!(
+            extension::MimeType::TEXT_PLAIN,
+            *metadatas[0].get_mime_type()
+        );
         assert_eq!("Hello World!", metadatas[0].get_metadata_utf8());
         assert_eq!(
             MimeType::from("application/not_well"),

rsocket-test/tests/test_frames.rs

@@ -20,7 +20,7 @@ fn test_setup() {
 
 #[test]
 fn test_keepalive() {
-    let f = Keepalive::builder(1234, FLAG_RESPOND)
+    let f = Keepalive::builder(1234, Frame::FLAG_RESPOND)
         .set_last_received_position(123)
         .set_data(Bytes::from("foobar"))
         .build();
@@ -38,7 +38,7 @@ fn test_request_response() {
 
 #[test]
 fn test_payload() {
-    let f = Payload::builder(1234, FLAG_NEXT | FLAG_COMPLETE)
+    let f = Payload::builder(1234, Frame::FLAG_NEXT | Frame::FLAG_COMPLETE)
         .set_data(Bytes::from("Hello World!"))
         .set_metadata(Bytes::from("foobar"))
         .build();
@@ -111,7 +111,7 @@ fn resume_ok() {
 
 #[test]
 fn test_resume() {
-    let f = Resume::builder(0, FLAG_RESUME)
+    let f = Resume::builder(0, Frame::FLAG_RESUME)
         .set_last_received_server_position(123)
         .set_first_available_client_position(22)
         .set_token(Bytes::from("this is a token"))

rsocket-test/tests/test_messaging.rs

@@ -32,6 +32,8 @@ async fn test_messaging() {
         .start()
         .await
         .expect("Connect failed!");
+
+    let rsocket: Box<dyn RSocket> = Box::new(rsocket);
     let requester = Requester::from(rsocket);
 
     let post = Student {
@@ -52,8 +54,3 @@ async fn test_messaging() {
         .expect("Empty result!");
     println!("------> RESPONSE: {:?}", res);
 }
-
-#[test]
-fn test_builder() {
-    RequesterBuilder::default().data_mime_type("application/json");
-}

rsocket-test/tests/test_mimes.rs

@@ -5,7 +5,7 @@ use rsocket_rust::extension::{self, MimeType};
 #[test]
 fn test_wellknown() {
     let well = MimeType::from("application/json");
-    assert_eq!(extension::MIME_APPLICATION_JSON, well);
+    assert_eq!(extension::MimeType::APPLICATION_JSON, well);
     assert_eq!(0x05, well.as_u8().unwrap());
     let custom = MimeType::from("application/custom");
     assert_eq!(MimeType::Normal("application/custom".to_owned()), custom);

rsocket-transport-tcp/src/codec.rs

@@ -1,6 +1,6 @@
 use bytes::{Buf, BytesMut};
 use rsocket_rust::frame::Frame;
-use rsocket_rust::utils::{Writeable, U24};
+use rsocket_rust::utils::{u24, Writeable};
 use std::io::{Error, ErrorKind};
 use tokio_util::codec::{Decoder, Encoder};
 
@@ -15,7 +15,7 @@ impl Decoder for LengthBasedFrameCodec {
         if actual < 3 {
             return Ok(None);
         }
-        let l = U24::read(buf) as usize;
+        let l = u24::read(buf).into();
         if actual < 3 + l {
             return Ok(None);
         }
@@ -33,7 +33,7 @@ impl Encoder<Frame> for LengthBasedFrameCodec {
     fn encode(&mut self, item: Frame, buf: &mut BytesMut) -> Result<(), Self::Error> {
         let l = item.len();
         buf.reserve(3 + l);
-        U24::write(l as u32, buf);
+        u24::from(l).write_to(buf);
         item.write_to(buf);
         Ok(())
     }

rsocket/src/extension/composite.rs

@@ -1,6 +1,6 @@
 use super::mime::MimeType;
 use crate::error::{ErrorKind, RSocketError};
-use crate::utils::{RSocketResult, Writeable, U24};
+use crate::utils::{u24, RSocketResult, Writeable};
 use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::collections::LinkedList;
 use std::convert::TryFrom;
@@ -141,7 +141,7 @@ impl CompositeMetadata {
                 "broken composite metadata: not enough bytes!",
             ));
         }
-        let payload_size = U24::read_advance(bs) as usize;
+        let payload_size = u24::read_advance(bs).into();
         if bs.len() < payload_size {
             return Err(RSocketError::from(format!(
                 "broken composite metadata: require {} bytes!",
@@ -159,7 +159,7 @@ impl CompositeMetadata {
 
 impl CompositeMetadataEntry {
     pub fn new(mime_type: MimeType, metadata: Bytes) -> CompositeMetadataEntry {
-        assert!(metadata.len() <= (U24::MAX as usize));
+        assert!(metadata.len() <= (u24::MAX as usize));
         CompositeMetadataEntry {
             mime_type,
             metadata,
@@ -196,8 +196,8 @@ impl Writeable for CompositeMetadataEntry {
                 bf.put_slice(s.as_ref());
             }
         };
-        let metadata_len = self.metadata.len() as u32;
-        U24::write(metadata_len, bf);
+        let metadata_len = self.metadata.len();
+        u24::from(metadata_len).write_to(bf);
         if metadata_len > 0 {
             bf.put(self.metadata.bytes());
         }