Broken WIP (waiting on atom-soundness)

Author: prokopyl

buf-size/src/options.rs

@@ -17,18 +17,18 @@ macro_rules! make_option {
             const URI: &'static [u8] = $uri;
         }
 
-        impl<'a> lv2_options::OptionType<'a> for $name {
+        impl lv2_options::OptionType for $name {
             type AtomType = lv2_atom::scalar::Int;
 
             #[inline]
-            fn from_option_value(
+            fn from_option_value<'a>(
                 value: <lv2_atom::scalar::Int as Atom<'a, 'a>>::ReadHandle,
             ) -> Option<Self> {
                 Some(Self((*value)))
             }
 
             #[inline]
-            fn as_option_value(&'a self) -> <lv2_atom::scalar::Int as Atom<'a, 'a>>::ReadHandle {
+            fn as_option_value<'a>(&'a self) -> <lv2_atom::scalar::Int as Atom<'a, 'a>>::ReadHandle {
                 &self.0
             }
         }

options/src/collection.rs

@@ -0,0 +1,90 @@
+use urid::{URIDCollection, Map};
+use crate::request::OptionRequestList;
+use crate::{OptionsError, OptionValue};
+use crate::list::OptionsList;
+use crate::option::request::OptionRequest;
+
+pub trait OptionsCollection: Sized {
+    type Serializer;
+
+    #[inline]
+    fn new_serializer<'a, M: Map + ?Sized>(map: &M) -> Option<OptionsSerializer<Self>>
+        where Self::Serializer: OptionsSerializationContext<'a, Self> { // FIXME
+        Some(OptionsSerializer { inner: Self::Serializer::from_map(map)? })
+    }
+}
+
+#[doc(hidden)]
+pub mod implementation {
+    use crate::{OptionType, OptionsError, OptionValue};
+    use std::marker::PhantomData;
+    use urid::{URID, URIDCollection, Map};
+    use crate::collection::{OptionsSerializationContext, OptionsCollection};
+    use crate::option::request::OptionRequest;
+    use lv2_atom::{Atom, BackAsSpace};
+    use lv2_atom::scalar::ScalarAtom;
+
+    pub struct OptionTypeSerializationContext<O: OptionType> {
+        option_urid: URID<O>,
+        option_type_atom_urid: URID<O::AtomType>
+    }
+
+    impl<'a, O: OptionType> OptionsCollection for O
+        where <O as OptionType>::AtomType: BackAsSpace<'a>,
+              <<O as OptionType>::AtomType as Atom<'a, 'a>>::ReadParameter: Default {
+        type Serializer = OptionTypeSerializationContext<O>;
+    }
+
+    impl<O: OptionType> URIDCollection for OptionTypeSerializationContext<O> {
+        #[inline]
+        fn from_map<M: Map + ?Sized>(map: &M) -> Option<Self> {
+            Some(Self {
+                option_urid: map.populate_collection()?,
+                option_type_atom_urid: map.populate_collection()?,
+            })
+        }
+    }
+
+    impl<'a, O: OptionType> OptionsSerializationContext<'a, O> for OptionTypeSerializationContext<O>
+        where <O as OptionType>::AtomType: BackAsSpace<'a>,
+              <<O as OptionType>::AtomType as Atom<'a, 'a>>::ReadParameter: Default {
+        #[inline]
+        fn deserialize_new(&self, option: &'a OptionValue) -> Option<O> {
+            option.read(self.option_urid, self.option_type_atom_urid, Default::default())
+        }
+
+        fn deserialize_to(&self, options: &mut O, option: &OptionValue) -> Result<(), OptionsError> {
+            todo!()
+        }
+
+        fn respond_to_request<'r>(&self, options: &'r O, requests: &'r mut OptionRequest) -> Result<(), OptionsError> {
+            todo!()
+        }
+    }
+}
+
+pub struct OptionsSerializer<T: OptionsCollection> {
+    inner: T::Serializer
+}
+
+impl<T: OptionsCollection> OptionsSerializer<T> {
+    pub fn deserialize_new(&self, list: &OptionsList) -> Option<T> {
+        todo!()
+    }
+
+    pub fn deserialize_to(&self, options: &mut T, list: &OptionsList) -> Result<(), OptionsError> {
+        todo!()
+    }
+
+    pub fn respond_to_requests<'a>(&self, options: &T, requests: &mut OptionRequestList) -> Result<(), OptionsError> {
+        todo!()
+    }
+}
+
+pub trait OptionsSerializationContext<'a, T: OptionsCollection>: URIDCollection {
+    fn deserialize_new(&self, option: &'a OptionValue) -> Option<T>;
+
+    fn deserialize_to(&self, options: &mut T, option: &OptionValue) -> Result<(), OptionsError>;
+
+    fn respond_to_request<'r>(&self, options: &'r T, request: &'r mut OptionRequest) -> Result<(), OptionsError>;
+}

options/src/extensions.rs

@@ -1,6 +1,6 @@
 //! Contains the [`OptionsInterface`](crate::extensions::OptionsInterface) extension interface.
 use crate::features::OptionsList;
-use crate::{OptionsError, OptionsWriter};
+use crate::OptionsError;
 use lv2_core::feature::Feature;
 use lv2_core::plugin::PluginInstance;
 use lv2_core::prelude::Plugin;
@@ -9,6 +9,7 @@ use std::ffi::c_void;
 use std::marker::PhantomData;
 use std::panic::AssertUnwindSafe;
 use urid::UriBound;
+use crate::option::request::OptionRequestList;
 
 /// An interface to allow dynamically setting options from the host.
 ///
@@ -18,11 +19,10 @@ use urid::UriBound;
 ///
 /// ```
 /// # use lv2_core::prelude::*;
-/// # use lv2_options::{OptionType, OptionsWriter, OptionsError, Subject};
-/// # use lv2_options::features::OptionsList;
-/// # use lv2_options::extensions::{OptionsDescriptor, OptionsInterface};
+/// # use lv2_options::OptionType;
+/// # use lv2_options::prelude::*;
 /// #
-/// # use urid::{URID, Uri};
+/// # use urid::{URID, Uri, URIDCollection, uri, Map, UriBound};
 /// # use std::any::Any;
 /// #
 /// # impl<'a> OptionType<'a> for SomeIntOption {
@@ -111,7 +111,7 @@ pub trait OptionsInterface: Plugin {
     /// If the given options are unknown or somehow invalid, the appropriate [`OptionsError`] is returned.
     ///
     /// See the documentation for the [`OptionsInterface`] type for an example of how to implement this method.
-    fn get(&self, writer: OptionsWriter) -> Result<(), OptionsError>;
+    fn get(&self, requests: OptionRequestList) -> Result<(), OptionsError>;
 
     /// Allows the host to set the plugin's values for the given options.
     ///
@@ -121,6 +121,7 @@ pub trait OptionsInterface: Plugin {
     fn set(&mut self, options: OptionsList) -> Result<(), OptionsError>;
 }
 
+/// The Extension Descriptor associated to [`OptionsInterface`].
 pub struct OptionsDescriptor<P: OptionsInterface> {
     plugin: PhantomData<P>,
 }
@@ -140,16 +141,14 @@ impl<P: OptionsInterface> OptionsDescriptor<P> {
         }
         .plugin_handle();
 
-        let options =
-            match OptionsList::from_feature_ptr(options_list.cast(), ThreadingClass::Instantiation)
-            {
-                Some(options) => options,
-                None => return lv2_sys::LV2_Options_Status_LV2_OPTIONS_ERR_UNKNOWN,
-            };
+        let options_list = match options_list.as_mut() {
+            Some(options_list) => options_list,
+            None => return lv2_sys::LV2_Options_Status_LV2_OPTIONS_ERR_UNKNOWN,
+        };
 
-        let writer = OptionsWriter::new(options);
+        let requests = OptionRequestList::from_mut(options_list);
 
-        match std::panic::catch_unwind(AssertUnwindSafe(|| instance.get(writer))) {
+        match std::panic::catch_unwind(AssertUnwindSafe(|| instance.get(requests))) {
             Ok(r) => OptionsError::result_into_raw(r),
             Err(_) => lv2_sys::LV2_Options_Status_LV2_OPTIONS_ERR_UNKNOWN,
         }

options/src/lib.rs

@@ -17,15 +17,25 @@
 //! See the [LV2 Options documentation](http://lv2plug.in/ns/ext/options) for more information.
 
 pub use option::error::OptionsError;
+pub use option::OptionType;
+pub use option::request;
 pub use option::subject::Subject;
 pub use option::value::OptionValue;
-pub use option::writer::{OptionsProcessor, OptionsWriter};
-pub use option::OptionType;
 
 pub mod extensions;
 mod option;
+pub mod list;
+pub mod collection;
 
 /// Contains the [`OptionsList`](features::OptionsList) feature.
 pub mod features {
-    pub use crate::option::list::OptionsList;
+    pub use crate::list::OptionsList;
 }
+
+/// Prelude of `lv2_options` for wildcard usage.
+pub mod prelude {
+    pub use crate::list::OptionsList;
+    pub use crate::OptionsError;
+    pub use crate::Subject;
+    pub use crate::extensions::{OptionsDescriptor, OptionsInterface};
+}

options/src/list.rs

@@ -0,0 +1,70 @@
+use crate::OptionValue;
+use core::ffi::c_void;
+use lv2_core::feature::{Feature, ThreadingClass};
+use urid::UriBound;
+
+/// A read-only list of [`OptionValue`]s, sent from the host.
+///
+/// This list type doesn't own the contained values: they are simply borrowed from the host.
+/// Cloning this struct only clones the list, not its contents.
+#[derive(Copy, Clone)]
+pub struct OptionsList<'a> {
+    options_list: &'a lv2_sys::LV2_Options_Option,
+}
+
+impl<'f> OptionsList<'f> {
+    /// Returns an iterator over the slice.
+    #[inline]
+    pub fn iter(&self) -> OptionsListIter<'f> {
+        OptionsListIter { current: self.options_list }
+    }
+}
+
+unsafe impl<'a> UriBound for OptionsList<'a> {
+    const URI: &'static [u8] = lv2_sys::LV2_OPTIONS__options;
+}
+
+unsafe impl<'a> Feature for OptionsList<'a> {
+    #[inline]
+    unsafe fn from_feature_ptr(feature: *const c_void, _class: ThreadingClass) -> Option<Self> {
+        // SAFETY: Type and contents of feature data pointer is guaranteed by caller
+        Some(OptionsList {
+            options_list: (feature as *const _ as *mut lv2_sys::LV2_Options_Option).as_ref()?,
+        })
+    }
+}
+
+impl<'a> IntoIterator for &'a OptionsList<'a> {
+    type Item = &'a OptionValue;
+    type IntoIter = OptionsListIter<'a>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+pub struct OptionsListIter<'a> {
+    current: &'a lv2_sys::LV2_Options_Option
+}
+
+impl<'a> Iterator for OptionsListIter<'a> {
+    type Item = &'a OptionValue;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        let item = self.current;
+        if item.key == 0 {
+            return None;
+        }
+
+        // SAFETY: list is guaranteed by the host to end with a zeroed struct.
+        // Therefore the pointer always points to a valid lv2_sys::LV2_Options_Option value
+        // (only its contents may be incorrect if zeroed)
+        unsafe {
+            self.current = &*((self.current as *const lv2_sys::LV2_Options_Option).add(1));
+        }
+
+        Some(OptionValue::from_ref(item))
+    }
+}

options/src/option.rs

@@ -2,17 +2,47 @@ use lv2_atom::Atom;
 use urid::UriBound;
 
 pub mod error;
-pub mod list;
 pub mod subject;
 pub mod value;
-pub mod writer;
+pub mod request;
 
-pub trait OptionType<'a>: UriBound + Sized + 'a {
-    type AtomType: Atom<'a, 'a>;
+/// A trait representing an LV2 Option type.
+///
+/// # Example
+///
+/// This example implements a simple option type named "MyIntOption" backed by an Int atom.
+///
+/// ```
+/// use lv2_options::OptionType;
+/// use urid::*;
+///
+/// #[uri("urn:lv2_options:test:SomeIntOption")]
+/// pub struct SomeIntOption(i32);
+///
+/// impl OptionType for SomeIntOption {
+///     type AtomType = lv2_atom::scalar::Int;
+///
+///     fn from_option_value(value: &i32) -> Option<Self> {
+///         Some(Self(*value))
+///     }
+///
+///     fn as_option_value(&self) -> &i32 {
+///         &self.0
+///     }
+/// }
+/// ```
+pub trait OptionType: UriBound + Sized {
+    type AtomType: UriBound;
 
-    fn from_option_value(
-        value: <Self::AtomType as Atom<'a, 'a>>::ReadHandle,
-    ) -> core::option::Option<Self>;
+    /// Creates a new instance of this Option type from a given atom value.
+    ///
+    /// This method may return `None` if the Atom's value is invalid for this option type.
+    ///
+    /// This method is used to store option data when received by the host.
+    fn from_option_value<'a>(value: <Self::AtomType as Atom<'a, 'a>>::ReadHandle) -> Option<Self> where Self::AtomType: Atom<'a, 'a>;
 
-    fn as_option_value(&'a self) -> <Self::AtomType as Atom<'a, 'a>>::ReadHandle;
+    /// Returns this Option's value as a reference to its Atom type.
+    ///
+    /// This method is used to send the option's value to the host when it is requested.
+    fn as_option_value<'a>(&'a self) -> <Self::AtomType as Atom<'a, 'a>>::ReadHandle  where Self::AtomType: Atom<'a, 'a>;
 }

options/src/option/error.rs

@@ -2,7 +2,10 @@ use std::error::Error;
 use std::fmt::{Display, Formatter};
 
 /// Errors raised when interacting with LV2 Options.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)] // TODO: better Debug/Display implementation
+///
+/// See the [LV2 Documentation](https://lv2plug.in/doc/html/group__options.html#ga94d649a74ab340dfc6c6751dbe92ca07)
+/// for more information.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
 #[non_exhaustive]
 pub enum OptionsError {
     Unknown = lv2_sys::LV2_Options_Status_LV2_OPTIONS_ERR_UNKNOWN as isize,
@@ -16,22 +19,35 @@ impl OptionsError {
     pub(crate) fn result_into_raw(value: Result<(), OptionsError>) -> lv2_sys::LV2_Options_Status {
         match value {
             Ok(()) => lv2_sys::LV2_Options_Status_LV2_OPTIONS_SUCCESS,
-            _ => lv2_sys::LV2_Options_Status_LV2_OPTIONS_ERR_UNKNOWN, // TODO
+            Err(OptionsError::BadSubject) => lv2_sys::LV2_Options_Status_LV2_OPTIONS_ERR_BAD_SUBJECT,
+            Err(OptionsError::BadKey) => lv2_sys::LV2_Options_Status_LV2_OPTIONS_ERR_BAD_KEY,
+            Err(OptionsError::BadValue) => lv2_sys::LV2_Options_Status_LV2_OPTIONS_ERR_BAD_VALUE,
+            Err(_) => lv2_sys::LV2_Options_Status_LV2_OPTIONS_ERR_UNKNOWN,
         }
     }
 
     #[inline]
     pub(crate) fn from_raw(status: lv2_sys::LV2_Options_Status) -> Result<(), OptionsError> {
         match status {
             lv2_sys::LV2_Options_Status_LV2_OPTIONS_SUCCESS => Ok(()),
-            _ => Err(OptionsError::Unknown), // TODO
+            lv2_sys::LV2_Options_Status_LV2_OPTIONS_ERR_BAD_SUBJECT => Err(OptionsError::BadSubject),
+            lv2_sys::LV2_Options_Status_LV2_OPTIONS_ERR_BAD_KEY => Err(OptionsError::BadKey),
+            lv2_sys::LV2_Options_Status_LV2_OPTIONS_ERR_BAD_VALUE => Err(OptionsError::BadValue),
+            _ => Err(OptionsError::Unknown),
         }
     }
 }
 
 impl Display for OptionsError {
-    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
-        todo!()
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let msg = match self {
+            OptionsError::Unknown => "Unknown error while reading/writing Option",
+            OptionsError::BadSubject => "Unknown Option subject",
+            OptionsError::BadKey => "Unknown Option key",
+            OptionsError::BadValue => "Invalid Option value"
+        };
+
+        write!(f, "{}", msg)
     }
 }