Post-merge fixes

Author: prokopyl

atom/src/atoms/scalar.rs

@@ -92,8 +92,8 @@ impl<A: ScalarAtom> Atom for A {
     }
 }
 
-impl<A: ScalarAtom> BackAsSpace for A {
-    fn back_as_space<'a>(handle: <Self::ReadHandle as AtomHandle<'a>>::Handle) -> &'a [u8] {
+impl<A: ScalarAtom> AtomAsBytes for A {
+    fn read_as_bytes<'a>(handle: <Self::ReadHandle as AtomHandle<'a>>::Handle) -> &'a [u8] {
         AlignedSpace::from_slice(::core::slice::from_ref(handle)).as_bytes()
     }
 }

atom/src/lib.rs

@@ -164,3 +164,28 @@ pub trait Atom: UriBound {
         writer: AtomWriter,
     ) -> Result<<Self::WriteHandle as AtomHandle>::Handle, AtomWriteError>;
 }
+
+/// An Atom super-trait that allows to get a byte slice from an atom's read handle.
+///
+/// Some LV2 APIs (such as `Option`) request a data pointer to the value of a given atom type, but
+/// in many cases that pointer can be simply retrieved from a reference to a raw value. Most notably,
+/// pointers to any scalar value (e.g. `&i32`) can be safely turned into a byte slice (`&[u8]).
+///
+/// However, not all atoms have this capability, hence the need for a separate trait that is not
+/// implemented for all types.
+///
+/// # Example
+///
+/// ```
+/// use lv2_atom::atoms::scalar::Int;
+/// use lv2_atom::AtomAsBytes;
+///
+/// let value: i32 = 42;
+/// let bytes: &[u8] = Int::read_as_bytes(&value);
+///
+/// assert_eq!(bytes.len(), ::core::mem::size_of::<i32>())
+/// ```
+pub trait AtomAsBytes: Atom {
+    /// Returns the type returned by an Atom's read handle as a byte slice.
+    fn read_as_bytes<'a>(handle: <Self::ReadHandle as AtomHandle<'a>>::Handle) -> &'a [u8];
+}

options/src/collection.rs

@@ -176,7 +176,7 @@ pub mod __implementation {
                     Some(value) => self.inner.deserialize_to(value, options),
                     None => match self.inner.deserialize_new(options) {
                         Ok(v) => {
-                            destination.insert(v);
+                            let _ = destination.insert(v);
                             Ok(())
                         }
                         Err(e) => Err(e),

options/src/extensions.rs

@@ -24,25 +24,21 @@ use urid::UriBound;
 /// #
 /// # use urid::{URID, Uri, URIDCollection, uri, Map, UriBound};
 /// # use std::any::Any;
+/// # use lv2_atom::atoms::scalar::Int;
+/// use lv2_options::collection::OptionsSerializer;
 /// #
-/// # impl<'a> OptionType<'a> for SomeIntOption {
-/// #    type AtomType = lv2_atom::scalar::Int;
+/// # impl OptionType for SomeIntOption {
+/// #    type AtomType = Int;
 /// #
 /// # fn from_option_value(value: &i32) -> Option<Self> {
 /// #        Some(Self(*value))
 /// #    }
 /// #
-/// #    fn as_option_value(&'a self) -> &'a i32 {
+/// #    fn as_option_value(&self) -> &i32 {
 /// #        &self.0
 /// #    }
 /// # }
 /// #
-/// # #[derive(URIDCollection)]
-/// pub struct PluginUridCollection {
-///     some_int_option: URID<SomeIntOption>,
-///     int: URID<lv2_atom::scalar::Int>,
-/// }
-/// #
 /// # #[derive(FeatureCollection)]
 /// # pub struct PluginFeatures<'a> {
 /// #    options: OptionsList<'a>,
@@ -51,7 +47,7 @@ use urid::UriBound;
 /// # #[uri("urn:lv2_options:test:OptionablePlugin")]
 /// pub struct OptionablePlugin {
 ///     some_int: SomeIntOption,
-///     urids: PluginUridCollection,
+///     some_int_serializer: OptionsSerializer<SomeIntOption>,
 /// }
 /// #
 /// # impl Plugin for OptionablePlugin {
@@ -82,26 +78,12 @@ use urid::UriBound;
 /// pub struct SomeIntOption(i32);
 ///
 /// impl OptionsInterface for OptionablePlugin {
-///    fn get<'a>(&'a self, mut writer: OptionsWriter<'a>) -> Result<(), OptionsError> {
-///         writer.process(|subject, options| match subject { // We will want to get/set our opions differently depending on the subject
-///             Subject::Instance => { // In our case however, only our instance has an option
-///                 options.handle(self.urids.some_int_option, self.urids.int, || {
-///                     &self.some_int
-///                 });
-///             }
-///             _ => {}
-///         })
+///    fn get<'a>(&'a self, mut requests: OptionRequestList<'a>) -> Result<(), OptionsError> {
+///         self.some_int_serializer.respond_to_requests(&self.some_int, &mut requests)
 ///     }
 ///
 ///     fn set(&mut self, options: OptionsList) -> Result<(), OptionsError> {
-///         options.process(|subject, options| match subject {
-///             Subject::Instance => {
-///                 options.handle(self.urids.some_int_option, self.urids.int, (), |value| {
-///                     self.some_int = value
-///                 })
-///             }
-///             _ => {}
-///         })
+///         self.some_int_serializer.deserialize_to(&mut self.some_int, &options)
 ///     }
 /// }
 /// ```

options/src/lib.rs

@@ -34,8 +34,10 @@ pub mod features {
 
 /// Prelude of `lv2_options` for wildcard usage.
 pub mod prelude {
-    pub use crate::extensions::{OptionsDescriptor, OptionsInterface};
-    pub use crate::list::OptionsList;
-    pub use crate::OptionsError;
-    pub use crate::Subject;
+    pub use crate::{
+        extensions::{OptionsDescriptor, OptionsInterface},
+        list::OptionsList,
+        request::{OptionRequest, OptionRequestList},
+        OptionsError, Subject,
+    };
 }

options/src/option.rs

@@ -1,4 +1,4 @@
-use lv2_atom::{Atom, AtomHandle, BackAsSpace};
+use lv2_atom::{Atom, AtomAsBytes, AtomHandle};
 use urid::UriBound;
 
 pub mod error;
@@ -20,7 +20,7 @@ pub mod value;
 /// pub struct SomeIntOption(i32);
 ///
 /// impl OptionType for SomeIntOption {
-///     type AtomType = lv2_atom::scalar::Int;
+///     type AtomType = lv2_atom::atoms::scalar::Int;
 ///
 ///     fn from_option_value(value: &i32) -> Option<Self> {
 ///         Some(Self(*value))
@@ -32,7 +32,7 @@ pub mod value;
 /// }
 /// ```
 pub trait OptionType: UriBound + Sized {
-    type AtomType: BackAsSpace;
+    type AtomType: AtomAsBytes;
 
     /// Creates a new instance of this Option type from a given atom value.
     ///

options/src/option/request.rs

@@ -1,5 +1,5 @@
 use crate::{OptionType, OptionValue, OptionsError, Subject};
-use lv2_atom::{Atom, AtomHandle, BackAsSpace};
+use lv2_atom::{Atom, AtomAsBytes, AtomHandle};
 use std::marker::PhantomData;
 use urid::URID;
 
@@ -45,7 +45,7 @@ impl<'a> OptionRequest<'a> {
         value: &'a T,
     ) -> Result<(), OptionsError>
     where
-        T::AtomType: BackAsSpace,
+        T::AtomType: AtomAsBytes,
     {
         if !self.is(option_type) {
             return Err(OptionsError::BadKey);
@@ -62,9 +62,9 @@ impl<'a> OptionRequest<'a> {
         value_type: URID<T>,
         value_handle: <<T as Atom>::ReadHandle as AtomHandle>::Handle,
     ) where
-        T: BackAsSpace,
+        T: AtomAsBytes,
     {
-        let data = T::back_as_space(value_handle);
+        let data = T::read_as_bytes(value_handle);
         self.inner.type_ = value_type.get();
         self.inner.size = data.len() as u32;
         self.inner.value = data.as_ptr().cast();

options/src/option/value.rs

@@ -64,6 +64,6 @@ impl OptionValue {
         &self,
     ) -> Option<<<T as Atom>::ReadHandle as AtomHandle>::Handle> {
         // TODO: Atoms can actually be from non-aligned spaces
-        T::read(AtomSpace::from_bytes_unchecked(self.data()?))
+        T::read(AtomSpace::from_bytes_unchecked(self.data()?)).ok()
     }
 }