Merge pull request #85 from Janonard/develop

Making URIDs generic for all functions

Author: JOOpdenhoevel

atom/src/object.rs

@@ -61,7 +61,7 @@
 //!     ).unwrap();
 //!
 //!     // Write a property to the object.
-//!     object_writer.init(urids.property_a, None, urids.atom.int, 42).unwrap();
+//!     object_writer.init(urids.property_a, urids.atom.int, 42).unwrap();
 //! }
 //! ```
 //!
@@ -190,17 +190,32 @@ pub struct ObjectWriter<'a, 'b> {
 }
 
 impl<'a, 'b> ObjectWriter<'a, 'b> {
+    /// Initialize a new property with a context.
+    ///
+    /// This method does the same as [`init`](#method.init), but also sets the context URID.
+    pub fn init_with_context<'c, K: ?Sized, T: ?Sized, A: Atom<'a, 'c>>(
+        &'c mut self,
+        key: URID<K>,
+        context: URID<T>,
+        child_urid: URID<A>,
+        parameter: A::WriteParameter,
+    ) -> Option<A::WriteHandle> {
+        Property::write_header(&mut self.frame, key.into_general(), Some(context))?;
+        (&mut self.frame as &mut dyn MutSpace).init(child_urid, parameter)
+    }
+
     /// Initialize a new property.
     ///
     /// This method writes out the header of a property and returns a reference to the space, so the property values can be written.
-    pub fn init<'c, G: ?Sized, A: Atom<'a, 'c>>(
+    ///
+    /// Properties also have a context URID internally, which is rarely used. If you want to add one, use [`init_with_context`](#method.init_with_context).
+    pub fn init<'c, K: ?Sized, A: Atom<'a, 'c>>(
         &'c mut self,
-        key: URID<G>,
-        context: Option<URID>,
+        key: URID<K>,
         child_urid: URID<A>,
         parameter: A::WriteParameter,
     ) -> Option<A::WriteHandle> {
-        Property::write_header(&mut self.frame, key.into_general(), context)?;
+        Property::write_header::<K, ()>(&mut self.frame, key, None)?;
         (&mut self.frame as &mut dyn MutSpace).init(child_urid, parameter)
     }
 }
@@ -254,7 +269,11 @@ impl Property {
     /// Write out the header of a property atom.
     ///
     /// This method simply writes out the content of the header to the space and returns `Some(())` if it's successful.
-    fn write_header(space: &mut dyn MutSpace, key: URID, context: Option<URID>) -> Option<()> {
+    fn write_header<K: ?Sized, C: ?Sized>(
+        space: &mut dyn MutSpace,
+        key: URID<K>,
+        context: Option<URID<C>>,
+    ) -> Option<()> {
         space.write(&key.get(), true)?;
         space.write(&context.map(|urid| urid.get()).unwrap_or(0), false)?;
         Some(())
@@ -302,14 +321,10 @@ mod tests {
             )
             .unwrap();
             {
-                writer
-                    .init(first_key, None, urids.int, first_value)
-                    .unwrap();
+                writer.init(first_key, urids.int, first_value).unwrap();
             }
             {
-                writer
-                    .init(second_key, None, urids.float, second_value)
-                    .unwrap();
+                writer.init(second_key, urids.float, second_value).unwrap();
             }
         }
 

state/src/raw.rs

@@ -34,7 +34,8 @@ impl<'a> StoreHandle<'a> {
     /// This will return a new handle to create a property. Once the property is completely written, you can commit it by calling [`commit`](#method.commit) or [`commit_all`](#method.commit_all). Then, and only then, it will be saved by the host.
     ///
     /// If you began to write a property and don't want the written things to be stored, you can discard it with [`discard`](#method.discard) or [`discard_all`](#method.discard_all).
-    pub fn draft(&mut self, property_key: URID) -> StatePropertyWriter {
+    pub fn draft<K: ?Sized>(&mut self, property_key: URID<K>) -> StatePropertyWriter {
+        let property_key = property_key.into_general();
         self.properties
             .insert(property_key, SpaceElement::default());
         StatePropertyWriter::new(SpaceHead::new(
@@ -43,10 +44,10 @@ impl<'a> StoreHandle<'a> {
     }
 
     /// Internal helper function to store a property.
-    pub fn commit_pair(
+    pub fn commit_pair<K: ?Sized>(
         store_fn: sys::LV2_State_Store_Function,
         handle: sys::LV2_State_Handle,
-        key: URID,
+        key: URID<K>,
         space: SpaceElement,
     ) -> Result<(), StateErr> {
         let store_fn = store_fn.ok_or(StateErr::BadCallback)?;
@@ -83,7 +84,8 @@ impl<'a> StoreHandle<'a> {
     /// Commit one specific property.
     ///
     /// This method returns `None` if the requested property was not marked for commit, `Some(Ok(()))` if the property was stored and `Some(Err(_))` if an error occured while storing the property.
-    pub fn commit(&mut self, key: URID) -> Option<Result<(), StateErr>> {
+    pub fn commit<K: ?Sized>(&mut self, key: URID<K>) -> Option<Result<(), StateErr>> {
+        let key = key.into_general();
         let space = self.properties.remove(&key)?;
         Some(Self::commit_pair(self.store_fn, self.handle, key, space))
     }
@@ -96,8 +98,8 @@ impl<'a> StoreHandle<'a> {
     /// Discard a drafted property.
     ///
     /// If no property with the given key was drafted before, this is a no-op.
-    pub fn discard(&mut self, key: URID) {
-        self.properties.remove(&key);
+    pub fn discard<K: ?Sized>(&mut self, key: URID<K>) {
+        self.properties.remove(&key.into_general());
     }
 }
 
@@ -158,7 +160,7 @@ impl<'a> RetrieveHandle<'a> {
     /// Try to retrieve a property from the host.
     ///
     /// This method calls the internal retrieve callback with the given URID. If there's no property with the given URID, `Err(StateErr::NoProperty)` is returned. Otherwise, a reading handle is returned that contains the type and the data of the property and can interpret it as an atom.
-    pub fn retrieve(&self, key: URID) -> Result<StatePropertyReader, StateErr> {
+    pub fn retrieve<K: ?Sized>(&self, key: URID<K>) -> Result<StatePropertyReader, StateErr> {
         let mut size: usize = 0;
         let mut type_: u32 = 0;
         let property_ptr: *const std::ffi::c_void = unsafe {
@@ -192,8 +194,11 @@ pub struct StatePropertyReader<'a> {
 
 impl<'a> StatePropertyReader<'a> {
     /// Create a new reading handle with the given type and data.
-    pub fn new(type_: URID, body: Space<'a>) -> Self {
-        Self { type_, body }
+    pub fn new<T: ?Sized>(type_: URID<T>, body: Space<'a>) -> Self {
+        Self {
+            type_: type_.into_general(),
+            body,
+        }
     }
 
     /// Return the type of the property.

state/src/storage.rs

@@ -23,8 +23,9 @@ impl Default for Storage {
 
 impl Storage {
     /// Store a property.
-    pub fn store(&mut self, key: URID, type_: URID, value: &[u8]) {
-        self.items.insert(key, (type_, value.to_owned()));
+    pub fn store<K: ?Sized, T: ?Sized>(&mut self, key: URID<K>, type_: URID<T>, value: &[u8]) {
+        self.items
+            .insert(key.into_general(), (type_.into_general(), value.to_owned()));
     }
 
     /// External version of [`store`](#method.store).
@@ -60,9 +61,9 @@ impl Storage {
     /// Try to retrieve a property.
     ///
     /// If the property doesn't exist, `None` is returned.
-    pub fn retrieve(&self, key: URID) -> Option<(URID, &[u8])> {
+    pub fn retrieve<K: ?Sized>(&self, key: URID<K>) -> Option<(URID, &[u8])> {
         self.items
-            .get(&key)
+            .get(&key.into_general())
             .map(|(urid, data)| (*urid, data.as_ref()))
     }