Fixed data read/write methods

Added extensions creators

Signed-off-by: Francesco Guardiani <[email protected]>

Author: slinkydeveloper

src/event/attributes.rs

@@ -31,7 +31,10 @@ pub trait AttributesWriter {
         extension_name: &'event str,
         extension_value: impl Into<ExtensionValue>,
     );
-    fn remove_extension<'event>(&'event mut self, extension_name: &'event str) -> Option<ExtensionValue>;
+    fn remove_extension<'event>(
+        &'event mut self,
+        extension_name: &'event str,
+    ) -> Option<ExtensionValue>;
 }
 
 pub enum Attributes {
@@ -138,7 +141,10 @@ impl AttributesWriter for Attributes {
         }
     }
 
-    fn remove_extension<'event>(&'event mut self, extension_name: &'event str) -> Option<ExtensionValue> {
+    fn remove_extension<'event>(
+        &'event mut self,
+        extension_name: &'event str,
+    ) -> Option<ExtensionValue> {
         match self {
             Attributes::V10(a) => a.remove_extension(extension_name),
         }

src/event/data.rs

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use std::convert::TryInto;
 
 #[derive(Debug, Deserialize, Serialize, PartialEq, Clone)]
 /// Possible data values
@@ -76,12 +77,21 @@ pub enum Data {
 //     }
 // }
 
-//TODO this should be generified for event?!
-
-pub trait DataEncoder<T: Sized, E: std::error::Error> {
-    fn encode_data(value: &T) -> Result<Data, E>;
+impl Into<Data> for String {
+    fn into(self) -> Data {
+        Data::String(self)
+    }
 }
 
-pub trait DataDecoder<T: Sized, E: std::error::Error> {
-    fn decode_data(data: &Data) -> Result<&T, E>;
+// TODO Define an error here?
+impl TryInto<String> for Data {
+    type Error = ();
+
+    fn try_into(self) -> Result<String, Self::Error> {
+        match self {
+            Data::String(s) => Ok(s),
+            Data::Binary(v) => String::from_utf8(v).map_err(|e| ()),
+            _ => Err(()),
+        }
+    }
 }

src/event/event.rs

@@ -1,6 +1,7 @@
-use super::{Attributes, Data, DataDecoder, DataEncoder, AttributesReader, AttributesWriter, SpecVersion, ExtensionValue};
-use delegate::delegate;
+use super::{Attributes, AttributesReader, AttributesWriter, Data, ExtensionValue, SpecVersion};
 use chrono::{DateTime, FixedOffset};
+use delegate::delegate;
+use std::convert::{TryFrom, TryInto};
 
 pub struct Event {
     pub attributes: Attributes,
@@ -47,27 +48,38 @@ impl AttributesWriter for Event {
     }
 }
 
-pub trait DataWriter<T: Sized, E: std::error::Error, D: DataEncoder<T, E>>
-    where
-        Self: Sized,
-{
-    fn write_payload(&mut self, value: &T) -> Result<(), E>;
-}
+impl Event {
+    fn remove_data(&mut self) {
+        self.data = None;
+    }
 
-pub trait DataReader<T: Sized, E: std::error::Error, D: DataDecoder<T, E>> {
-    fn read_data(&self) -> Option<Result<&T, E>>;
-}
+    fn write_data(&mut self, v: impl Into<Data>) {
+        self.data = Some(v.into());
+    }
 
-impl <T: Sized, E: std::error::Error, D: DataEncoder<T, E>> DataWriter<T, E, D> for Event {
-    fn write_payload(&mut self, value: &T) -> Result<(), E> {
-        self.data = Some(D::encode_data(value)?);
+    fn try_write_data<E: std::error::Error>(
+        &mut self,
+        v: impl TryInto<Data, Error = E>,
+    ) -> Result<(), E> {
+        self.data = Some(v.try_into()?);
         Ok(())
     }
-}
 
-impl <T: Sized, E: std::error::Error, D: DataDecoder<T, E>> DataReader<T, E, D> for Event {
-    fn read_data(&self) -> Option<Result<&T, E>> {
-        self.data.as_ref().map(D::decode_data)
+    fn get_data<T: Sized + TryFrom<Data, Error = E>, E: std::error::Error>(
+        &self,
+    ) -> Option<Result<T, E>> {
+        match self.data.as_ref() {
+            Some(d) => Some(T::try_from(d.clone())),
+            None => None,
+        }
     }
-}
 
+    fn into_data<T: Sized + TryFrom<Data, Error = E>, E: std::error::Error>(
+        self,
+    ) -> Option<Result<T, E>> {
+        match self.data {
+            Some(d) => Some(T::try_from(d)),
+            None => None,
+        }
+    }
+}

src/event/extensions.rs

@@ -17,49 +17,45 @@ pub enum ExtensionValue {
     Object(Value),
 }
 
-// impl ExtensionValue {
-//     /// Create an [`ExtensionValue`] from a [`Into<String>`].
-//     ///
-//     /// # Example
-//     ///
-//     /// ```
-//     /// use cloudevents::ExtensionValue;
-//     ///
-//     /// let value = ExtensionValue::from_string("value");
-//     /// assert_eq!(value, ExtensionValue::String("value".to_owned()));
-//     /// ```
-//     ///
-//     /// [`Into<String>`]: https://doc.rust-lang.org/std/convert/trait.Into.html
-//     /// [`ExtensionValue`]: enum.ExtensionValue.html
-//     pub fn from_string<S>(s: S) -> Self
-//         where
-//             S: Into<String>,
-//     {
-//         ExtensionValue::String(s.into())
-//     }
-//
-//     /// Create an [`ExtensionValue`] from a [`Serialize`] object.
-//     ///
-//     /// # Example
-//     ///
-//     /// ```
-//     /// use cloudevents::ExtensionValue;
-//     /// use serde_json::Value;
-//     /// use std::error::Error;
-//     ///
-//     /// fn main() -> Result<(), Box<Error>> {
-//     ///     let value = ExtensionValue::from_serializable("value")?;
-//     ///     assert_eq!(value, ExtensionValue::Object(Value::String("value".to_owned())));
-//     ///     Ok(())
-//     /// }
-//     /// ```
-//     ///
-//     /// [`Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html
-//     /// [`ExtensionValue`]: enum.ExtensionValue.html
-//     pub fn from_serializable<S>(s: S) -> Result<Self, Error>
-//         where
-//             S: Serialize,
-//     {
-//         Ok(ExtensionValue::Object(serde_json::to_value(s)?))
-//     }
-// }
+impl ExtensionValue {
+    /// Create an [`ExtensionValue`] from a [`Into<String>`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cloudevents::ExtensionValue;
+    ///
+    /// let value = ExtensionValue::from_string("value");
+    /// assert_eq!(value, ExtensionValue::String("value".to_owned()));
+    /// ```
+    ///
+    /// [`Into<String>`]: https://doc.rust-lang.org/std/convert/trait.Into.html
+    /// [`ExtensionValue`]: enum.ExtensionValue.html
+    pub fn from_string<S>(s: S) -> Self
+    where
+        S: Into<String>,
+    {
+        ExtensionValue::String(s.into())
+    }
+
+    pub fn from_i64<S>(s: S) -> Self
+    where
+        S: Into<i64>,
+    {
+        ExtensionValue::Integer(s.into())
+    }
+
+    pub fn from_bool<S>(s: S) -> Self
+    where
+        S: Into<bool>,
+    {
+        ExtensionValue::Boolean(s.into())
+    }
+
+    pub fn from_json_value<S>(s: S) -> Self
+    where
+        S: Into<serde_json::Value>,
+    {
+        ExtensionValue::Object(s.into())
+    }
+}

src/event/mod.rs

@@ -7,7 +7,6 @@ mod spec_version;
 pub use attributes::Attributes;
 pub(crate) use attributes::{AttributesReader, AttributesWriter};
 pub use data::Data;
-pub(crate) use data::{DataDecoder, DataEncoder};
 pub use event::Event;
 pub use extensions::ExtensionValue;
 pub use spec_version::SpecVersion;

src/event/v10/attributes.rs

@@ -60,7 +60,8 @@ impl AttributesReader for Attributes {
     }
 
     fn get_extensions(&self) -> Vec<(&str, &ExtensionValue)> {
-        self.extensions.iter()
+        self.extensions
+            .iter()
             .map(|(k, v)| (k.as_str(), v))
             .collect()
     }
@@ -103,10 +104,14 @@ impl AttributesWriter for Attributes {
         extension_name: &'event str,
         extension_value: impl Into<ExtensionValue>,
     ) {
-        self.extensions.insert(extension_name.to_owned(), extension_value.into());
+        self.extensions
+            .insert(extension_name.to_owned(), extension_value.into());
     }
 
-    fn remove_extension<'event>(&'event mut self, extension_name: &'event str) -> Option<ExtensionValue> {
+    fn remove_extension<'event>(
+        &'event mut self,
+        extension_name: &'event str,
+    ) -> Option<ExtensionValue> {
         self.extensions.remove(extension_name)
     }
 }

tests/event.rs

@@ -0,0 +1,4 @@
+use cloudevents_rust_sdk::Event;
+
+#[test]
+fn use_event() {}