WIP: Implement Options and BufSize extensions

Cargo.toml

@@ -19,6 +19,10 @@ maintenance = { status = "actively-developed" }
 version = "2.0.0"
 optional = true
 
+[dependencies.lv2-buf-size]
+version = "0.1.0"
+optional = true
+
 [dependencies.lv2-core]
 version = "3.0.0"
 optional = true
@@ -27,6 +31,10 @@ optional = true
 version = "1.2.0"
 optional = true
 
+[dependencies.lv2-options]
+version = "0.1.0"
+optional = true
+
 [dependencies.lv2-time]
 version = "0.1.3"
 optional = true
@@ -71,8 +79,10 @@ plugin = [
 ]
 full = [
     "lv2-atom",
+    "lv2-buf-size",
     "lv2-core",
     "lv2-midi",
+    "lv2-options",
     "lv2-time",
     "lv2-units",
     "urid",
@@ -86,9 +96,12 @@ wmidi = ["lv2-midi", "lv2-midi/wmidi"]
 [workspace]
 members = [
     "atom",
+    "buf-size",
     "core",
     "core/derive",
     "midi",
+    "options",
+    "options/derive",
     "state",
     "sys",
     "sys/tool",
@@ -110,9 +123,11 @@ lto = true
 [patch.crates-io]
 lv2 = { path = "." }
 lv2-atom = { path = "atom" }
+lv2-buf-size = { path = "buf-size" }
 lv2-core = { path = "core" }
 lv2-core-derive = { path = "core/derive" }
 lv2-midi = { path = "midi" }
+lv2-options = { path = "options" }
 lv2-state = { path = "state" }
 lv2-sys = { path = "sys" }
 lv2-time = { path = "time" }

atom/src/atoms.rs

@@ -0,0 +1,29 @@
+pub mod chunk;
+pub mod object;
+pub mod scalar;
+pub mod sequence;
+pub mod string;
+pub mod tuple;
+pub mod vector;
+
+use urid::*;
+
+/// An URID collection of all standard atom types, provided for convenience.
+#[derive(Clone, URIDCollection)]
+pub struct AtomURIDCollection {
+    pub blank: URID<object::Blank>,
+    pub double: URID<scalar::Double>,
+    pub float: URID<scalar::Float>,
+    pub int: URID<scalar::Int>,
+    pub long: URID<scalar::Long>,
+    pub urid: URID<scalar::AtomURID>,
+    pub bool: URID<scalar::Bool>,
+    pub vector: URID<vector::Vector>,
+    pub chunk: URID<chunk::Chunk>,
+    pub literal: URID<string::Literal>,
+    pub object: URID<object::Object>,
+    pub property: URID<object::Property>,
+    pub string: URID<string::String>,
+    pub tuple: URID<tuple::Tuple>,
+    pub sequence: URID<sequence::Sequence>,
+}

atom/src/atoms/chunk.rs

@@ -0,0 +1,125 @@
+//! An atom containing memory of undefined type.
+//!
+//! This contents of this atom is considered as a simple blob of data. It used, for example, by the host to transmit the size of a writable atom port. Since it is so simple, it does not need a reading or writing parameter.
+//!
+//! # Example
+//! ```
+//! use lv2_core::prelude::*;
+//! use lv2_atom::prelude::*;
+//!
+//! use lv2_atom::space::{AtomSpace, AtomWriter, SpaceWriter};
+//!
+//! #[derive(PortCollection)]
+//! struct MyPorts {
+//!     input: InputPort<AtomPort>,
+//!     output: OutputPort<AtomPort>,
+//! }
+//!
+//! fn run(ports: &mut MyPorts, urids: &AtomURIDCollection) {
+//!     let in_chunk: &AtomSpace = ports.input.read(urids.chunk).unwrap();
+//!     let mut out_chunk: AtomWriter = ports.output.write(urids.chunk).unwrap();
+//!
+//!     let bytes = in_chunk.as_bytes();
+//!     out_chunk.write_bytes(bytes).unwrap();
+//! }
+//! ```
+//!
+//! # Specification
+//!
+//! [http://lv2plug.in/ns/ext/atom/atom.html#Chunk](http://lv2plug.in/ns/ext/atom/atom.html#Chunk)
+use crate::space::error::{AtomReadError, AtomWriteError};
+use crate::space::*;
+use crate::AtomWriter;
+use crate::{Atom, AtomHandle};
+use urid::UriBound;
+
+/// An atom containing an arbitrary byte buffer.
+///
+/// [See also the module documentation.](index.html)
+pub struct Chunk;
+
+unsafe impl UriBound for Chunk {
+    const URI: &'static [u8] = sys::LV2_ATOM__Chunk;
+}
+
+pub struct ChunkReaderHandle;
+impl<'a> AtomHandle<'a> for ChunkReaderHandle {
+    type Handle = &'a AtomSpace;
+}
+
+pub struct ChunkWriterHandle;
+impl<'a> AtomHandle<'a> for ChunkWriterHandle {
+    type Handle = AtomWriter<'a>;
+}
+
+impl Atom for Chunk {
+    type ReadHandle = ChunkReaderHandle;
+    type WriteHandle = ChunkWriterHandle;
+
+    #[inline]
+    unsafe fn read(
+        body: &AtomSpace,
+    ) -> Result<<Self::ReadHandle as AtomHandle>::Handle, AtomReadError> {
+        Ok(body)
+    }
+
+    #[inline]
+    fn write(
+        frame: AtomWriter,
+    ) -> Result<<Self::WriteHandle as AtomHandle>::Handle, AtomWriteError> {
+        Ok(frame)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::atoms::chunk::*;
+    use crate::*;
+
+    #[test]
+    fn test_chunk_and_slice_writer() {
+        const SLICE_LENGTH: usize = 42;
+
+        let map = HashURIDMapper::new();
+        let urids = crate::atoms::AtomURIDCollection::from_map(&map).unwrap();
+
+        let mut raw_space = VecSpace::<AtomHeader>::new_with_capacity(64);
+        let raw_space = raw_space.as_space_mut();
+
+        // writing
+        {
+            let mut space = SpaceCursor::new(raw_space.as_bytes_mut());
+            let mut writer = space.write_atom(urids.chunk).unwrap();
+            let data = writer.allocate(SLICE_LENGTH).unwrap();
+
+            for (i, value) in data.iter_mut().enumerate() {
+                *value = i as u8;
+            }
+
+            space.write_value(41u8).unwrap();
+        }
+
+        // verifying
+        {
+            let atom = unsafe { raw_space.read().next_atom() }.unwrap();
+            assert_eq!(atom.header().size_of_body(), SLICE_LENGTH);
+            assert_eq!(atom.header().urid(), urids.chunk.get());
+
+            let data = atom.body().as_bytes();
+            for (i, value) in data.iter().enumerate() {
+                assert_eq!(*value as usize, i);
+            }
+        }
+
+        // reading
+        {
+            let data =
+                unsafe { Chunk::read(raw_space.read().next_atom().unwrap().body()) }.unwrap();
+            assert_eq!(data.bytes_len(), SLICE_LENGTH);
+
+            for (i, value) in data.as_bytes().iter().enumerate() {
+                assert_eq!(*value as usize, i);
+            }
+        }
+    }
+}