chore(data): create data crate

Author: LizAinslie

.idea/OpenSyndicationProtocol.iml

@@ -0,0 +1,15 @@
+[package]
+name = "data"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+uuid = { version = "1.9.1", features = ["v4"] }
+serde = { version = "1.0.203", optional = true }
+tokio = { version = "1", features = ["full"] }
+tokio-byteorder = "0.3.0"
+bytes = "1.6.0"
+
+[features]
+default = ["serde"]
+serde = ["dep:serde"]

Cargo.lock

@@ -0,0 +1,9 @@
+use uuid::Uuid;
+
+#[cfg(feature = "serde")]
+pub mod serde;
+mod ser;
+
+pub struct DataType<T> {
+    id: Uuid
+}

crates/data/Cargo.toml

@@ -0,0 +1,19 @@
+use bytes::BytesMut;
+
+pub struct DataSerializer<T> {
+    pub(crate) output: BytesMut,
+    pub(crate) bytes_written: usize,
+}
+
+impl<T> DataSerializer<T> {
+    pub fn new() -> Self {
+        DataSerializer {
+            output: BytesMut::new(),
+            bytes_written: 0,
+        }
+    }
+}
+
+pub trait SerializeData {
+    
+}

crates/data/src/lib.rs

@@ -0,0 +1,62 @@
+use serde::{de, ser};
+use std::fmt::{self, Display};
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+// This is a bare-bones implementation. A real library would provide additional
+// information in its error type, for example the line and column at which the
+// error occurred, the byte offset into the input, or the current key being
+// processed.
+#[derive(Debug)]
+pub enum Error {
+    // One or more variants that can be created by data structures through the
+    // `ser::Error` and `de::Error` traits. For example the Serialize impl for
+    // Mutex<T> might return an error because the mutex is poisoned, or the
+    // Deserialize impl for a struct may return an error because a required
+    // field is missing.
+    Message(String),
+
+    // Zero or more variants that can be created directly by the Serializer and
+    // Deserializer without going through `ser::Error` and `de::Error`. These
+    // are specific to the format, in this case JSON.
+    Eof,
+    // Syntax,
+    // ExpectedBoolean,
+    // ExpectedInteger,
+    // ExpectedString,
+    // ExpectedNull,
+    // ExpectedArray,
+    // ExpectedArrayComma,
+    // ExpectedArrayEnd,
+    // ExpectedMap,
+    // ExpectedMapColon,
+    // ExpectedMapComma,
+    // ExpectedMapEnd,
+    // ExpectedEnum,
+    // TrailingCharacters,
+}
+
+impl ser::Error for Error {
+    fn custom<T: Display>(msg: T) -> Self {
+        Error::Message(msg.to_string())
+    }
+}
+
+impl de::Error for Error {
+    fn custom<T: Display>(msg: T) -> Self {
+        Error::Message(msg.to_string())
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Error::Message(msg) => write!(f, "{}", msg),
+            Error::Eof => f.write_str("unexpected end of input"),
+            /* and so forth */
+            _ => unimplemented!(),
+        }
+    }
+}
+
+impl std::error::Error for Error {}

crates/data/src/ser.rs

@@ -0,0 +1,2 @@
+mod ser;
+mod error;

crates/data/src/serde/error.rs

@@ -0,0 +1,157 @@
+use bytes::{BufMut, BytesMut};
+use serde::{Serialize, ser};
+use crate::ser::DataSerializer;
+use crate::serde::error::{Error, Result};
+
+pub fn to_bytes<'ser, T>(value: &T) -> Result<&'ser mut BytesMut>
+where
+    T: Serialize,
+{
+    let mut serializer = DataSerializer::<T>::new();
+    value.serialize(&mut serializer)?;
+    Ok(&mut serializer.output)
+}
+
+impl<'a, Data> ser::Serializer for &'a mut DataSerializer<T> where Data : Serialize {
+    type Ok = ();
+    type Error = Error;
+    type SerializeSeq = ();
+    type SerializeTuple = ();
+    type SerializeTupleStruct = ();
+    type SerializeTupleVariant = ();
+    type SerializeMap = ();
+    type SerializeStruct = ();
+    type SerializeStructVariant = ();
+
+    fn serialize_bool(self, v: bool) -> Result<()> {
+        self.output.put_u8(v as u8)?
+    }
+
+    fn serialize_i8(self, v: i8) -> Result<()> {
+        self.output.put_i8(v)?
+    }
+
+    fn serialize_i16(self, v: i16) -> Result<()> {
+        self.output.put_i16(v)?
+    }
+
+    fn serialize_i32(self, v: i32) -> Result<()> {
+        self.output.put_i32(v)?
+    }
+
+    fn serialize_i64(self, v: i64) -> Result<()> {
+        self.output.put_i64(v)?
+    }
+
+    fn serialize_i128(self, v: i128) -> Result<()> {
+        self.output.put_i128(v)?
+    }
+
+    fn serialize_u8(self, v: u8) -> Result<()> {
+        self.output.put_u8(v)?
+    }
+
+    fn serialize_u16(self, v: u16) -> Result<()> {
+        self.output.put_u16(v)?
+    }
+
+    fn serialize_u32(self, v: u32) -> Result<()> {
+        self.output.put_u32(v)?
+    }
+
+    fn serialize_u64(self, v: u64) -> Result<()> {
+        self.output.put_u64(v)?
+    }
+
+    fn serialize_u128(self, v: u128) -> Result<()> {
+        self.output.put_u128(v)?
+    }
+
+    fn serialize_f32(self, v: f32) -> Result<()> {
+        self.output.put_f32(v)?
+    }
+
+    fn serialize_f64(self, v: f64) -> Result<()> {
+        self.output.put_f64(v)?
+    }
+
+    fn serialize_char(self, v: char) -> Result<()> {
+        self.output.put_u8(v as u8)?
+    }
+
+    fn serialize_str(self, v: &str) -> Result<()> {
+        let bytes = v.as_bytes();
+        self.output.put_u16(bytes.len() as u16);
+        self.output.put_slice(bytes);
+        Ok(())
+    }
+
+    fn serialize_bytes(self, v: &[u8]) -> Result<()> {
+        todo!()
+    }
+
+    fn serialize_none(self) -> Result<()> {
+        todo!()
+    }
+
+    fn serialize_some<T>(self, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize
+    {
+        todo!()
+    }
+
+    fn serialize_unit(self) -> Result<()> {
+        todo!()
+    }
+
+    fn serialize_unit_struct(self, name: &'static str) -> Result<()> {
+        todo!()
+    }
+
+    fn serialize_unit_variant(self, name: &'static str, variant_index: u32, variant: &'static str) -> Result<()> {
+        todo!()
+    }
+
+    fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize
+    {
+        todo!()
+    }
+
+    fn serialize_newtype_variant<T>(self, name: &'static str, variant_index: u32, variant: &'static str, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize
+    {
+        todo!()
+    }
+
+    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+        todo!()
+    }
+
+    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+        todo!()
+    }
+
+    fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
+        todo!()
+    }
+
+    fn serialize_tuple_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
+        todo!()
+    }
+
+    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+        todo!()
+    }
+
+    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
+        todo!()
+    }
+
+    fn serialize_struct_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
+        todo!()
+    }
+}