wip: compiles again, after extensive jack rework

crates/device/src/port/port_audio_in.rs

@@ -10,11 +10,15 @@ use crate::*;
     /// List of ports to connect to.
     pub connections: Vec<Connect>,
 }
-has!(Jack<'static>: |self: AudioInput|self.jack);
+impl HasJack<'static> for AudioInput {
+    fn jack (&self) -> &Jack<'static> {
+        &self.jack
+    }
+}
 impl JackPort for AudioInput {
     type Port = AudioIn;
     type Pair = AudioOut;
-    fn name (&self) -> &Arc<str> {
+    fn port_name (&self) -> &Arc<str> {
         &self.name
     }
     fn port (&self) -> &Port<Self::Port> {

crates/device/src/port/port_audio_out.rs

@@ -10,11 +10,15 @@ use crate::*;
     /// List of ports to connect to.
     pub connections: Vec<Connect>,
 }
-has!(Jack<'static>: |self: AudioOutput|self.jack);
+impl HasJack<'static> for AudioOutput {
+    fn jack (&self) -> &Jack<'static> {
+        &self.jack
+    }
+}
 impl JackPort for AudioOutput {
     type Port = AudioOut;
     type Pair = AudioIn;
-    fn name (&self) -> &Arc<str> {
+    fn port_name (&self) -> &Arc<str> {
         &self.name
     }
     fn port (&self) -> &Port<Self::Port> {

crates/device/src/port/port_connect.rs

@@ -1,181 +0,0 @@
-use crate::*;
-
-pub trait JackPort: HasJack<'static> {
-    type Port: PortSpec + Default;
-    type Pair: PortSpec + Default;
-    fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
-        -> Usually<Self> where Self: Sized;
-    fn register (jack: &Jack<'static>, name: &impl AsRef<str>) -> Usually<Port<Self::Port>> {
-        Ok(jack.register_port::<Self::Port>(name.as_ref())?)
-    }
-    fn name (&self) -> &Arc<str>;
-    fn connections (&self) -> &[Connect];
-    fn port (&self) -> &Port<Self::Port>;
-    fn port_mut (&mut self) -> &mut Port<Self::Port>;
-    fn into_port (self) -> Port<Self::Port> where Self: Sized;
-    fn close (self) -> Usually<()> where Self: Sized {
-        let jack = self.jack().clone();
-        Ok(jack.with_client(|c|c.unregister_port(self.into_port()))?)
-    }
-    fn ports (&self, re_name: Option<&str>, re_type: Option<&str>, flags: PortFlags) -> Vec<String> {
-        self.with_client(|c|c.ports(re_name, re_type, flags))
-    }
-    fn port_by_id (&self, id: u32) -> Option<Port<Unowned>> {
-        self.with_client(|c|c.port_by_id(id))
-    }
-    fn port_by_name (&self, name: impl AsRef<str>) -> Option<Port<Unowned>> {
-        self.with_client(|c|c.port_by_name(name.as_ref()))
-    }
-    fn connect_to_matching <'k> (&'k self) -> Usually<()> {
-        for connect in self.connections().iter() {
-            //panic!("{connect:?}");
-            let status = match &connect.name {
-                Exact(name) => self.connect_exact(name),
-                RegExp(re)  => self.connect_regexp(re, connect.scope),
-            }?;
-            *connect.status.write().unwrap() = status;
-        }
-        Ok(())
-    }
-    fn connect_exact <'k> (&'k self, name: &str) ->
-        Usually<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>>
-    {
-        self.with_client(move|c|{
-            let mut status = vec![];
-            for port in c.ports(None, None, PortFlags::empty()).iter() {
-                if port.as_str() == &*name {
-                    if let Some(port) = c.port_by_name(port.as_str()) {
-                        let port_status = self.connect_to_unowned(&port)?;
-                        let name = port.name()?.into();
-                        status.push((port, name, port_status));
-                        if port_status == Connected {
-                            break
-                        }
-                    }
-                }
-            }
-            Ok(status)
-        })
-    }
-    fn connect_regexp <'k> (
-        &'k self, re: &str, scope: ConnectScope
-    ) -> Usually<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>> {
-        self.with_client(move|c|{
-            let mut status = vec![];
-            let ports = c.ports(Some(&re), None, PortFlags::empty());
-            for port in ports.iter() {
-                if let Some(port) = c.port_by_name(port.as_str()) {
-                    let port_status = self.connect_to_unowned(&port)?;
-                    let name = port.name()?.into();
-                    status.push((port, name, port_status));
-                    if port_status == Connected && scope == One {
-                        break
-                    }
-                }
-            }
-            Ok(status)
-        })
-    }
-    /** Connect to a matching port by name. */
-    fn connect_to_name (&self, name: impl AsRef<str>) -> Usually<ConnectStatus> {
-        self.with_client(|c|if let Some(ref port) = c.port_by_name(name.as_ref()) {
-            self.connect_to_unowned(port)
-        } else {
-            Ok(Missing)
-        })
-    }
-    /** Connect to a matching port by reference. */
-    fn connect_to_unowned (&self, port: &Port<Unowned>) -> Usually<ConnectStatus> {
-        self.with_client(|c|Ok(if let Ok(_) = c.connect_ports(self.port(), port) {
-            Connected
-        } else if let Ok(_) = c.connect_ports(port, self.port()) {
-            Connected
-        } else {
-            Mismatch
-        }))
-    }
-    /** Connect to an owned matching port by reference. */
-    fn connect_to_owned (&self, port: &Port<Self::Pair>) -> Usually<ConnectStatus> {
-        self.with_client(|c|Ok(if let Ok(_) = c.connect_ports(self.port(), port) {
-            Connected
-        } else if let Ok(_) = c.connect_ports(port, self.port()) {
-            Connected
-        } else {
-            Mismatch
-        }))
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum ConnectName {
-    /** Exact match */
-    Exact(Arc<str>),
-    /** Match regular expression */
-    RegExp(Arc<str>),
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)] pub enum ConnectScope {
-    One,
-    All
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)] pub enum ConnectStatus {
-    Missing,
-    Disconnected,
-    Connected,
-    Mismatch,
-}
-
-#[derive(Clone, Debug)] pub struct Connect {
-    pub name:   ConnectName,
-    pub scope:  ConnectScope,
-    pub status: Arc<RwLock<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>>>,
-    pub info:   Arc<String>,
-}
-
-impl Connect {
-    pub fn collect (exact: &[impl AsRef<str>], re: &[impl AsRef<str>], re_all: &[impl AsRef<str>])
-        -> Vec<Self>
-    {
-        let mut connections = vec![];
-        for port in exact.iter()  { connections.push(Self::exact(port)) }
-        for port in re.iter()     { connections.push(Self::regexp(port)) }
-        for port in re_all.iter() { connections.push(Self::regexp_all(port)) }
-        connections
-    }
-    /// Connect to this exact port
-    pub fn exact (name: impl AsRef<str>) -> Self {
-        let info = format!("=:{}", name.as_ref()).into();
-        let name = Exact(name.as_ref().into());
-        Self { name, scope: One, status: Arc::new(RwLock::new(vec![])), info }
-    }
-    pub fn regexp (name: impl AsRef<str>) -> Self {
-        let info = format!("~:{}", name.as_ref()).into();
-        let name = RegExp(name.as_ref().into());
-        Self { name, scope: One, status: Arc::new(RwLock::new(vec![])), info }
-    }
-    pub fn regexp_all (name: impl AsRef<str>) -> Self {
-        let info = format!("+:{}", name.as_ref()).into();
-        let name = RegExp(name.as_ref().into());
-        Self { name, scope: All, status: Arc::new(RwLock::new(vec![])), info }
-    }
-    pub fn info (&self) -> Arc<str> {
-        let status = {
-            let status = self.status.read().unwrap();
-            let mut ok = 0;
-            for (_, _, state) in status.iter() {
-                if *state == Connected {
-                    ok += 1
-                }
-            }
-            format!("{ok}/{}", status.len())
-        };
-        let scope  = match self.scope {
-            One => " ", All => "*",
-        };
-        let name   = match &self.name {
-            Exact(name) => format!("= {name}"), RegExp(name) => format!("~ {name}"),
-        };
-        format!(" ({}) {} {}", status, scope, name).into()
-    }
-}

crates/device/src/port/port_midi_in.rs

@@ -14,11 +14,15 @@ use crate::*;
     /// List of ports to connect to.
     pub connections: Vec<Connect>,
 }
-has!(Jack<'static>: |self: MidiInput|self.jack);
+impl HasJack<'static> for MidiInput {
+    fn jack (&self) -> &Jack<'static> {
+        &self.jack
+    }
+}
 impl JackPort for MidiInput {
     type Port = MidiIn;
     type Pair = MidiOut;
-    fn name (&self) -> &Arc<str> {
+    fn port_name (&self) -> &Arc<str> {
         &self.name
     }
     fn port (&self) -> &Port<Self::Port> {
@@ -85,7 +89,7 @@ pub trait HasMidiIns {
         let mut y = 0;
         self.midi_ins().iter().enumerate().map(move|(i, input)|{
             let height = 1 + input.connections().len();
-            let data   = (i, input.name(), input.connections(), y, y + height);
+            let data   = (i, input.port_name(), input.connections(), y, y + height);
             y += height;
             data
         })

crates/device/src/port/port_midi_out.rs

@@ -16,11 +16,15 @@ use crate::*;
     /// Buffer
     output_buffer: Vec<Vec<Vec<u8>>>,
 }
-has!(Jack<'static>: |self: MidiOutput|self.jack);
+impl HasJack<'static> for MidiOutput {
+    fn jack (&self) -> &Jack<'static> {
+        &self.jack
+    }
+}
 impl JackPort for MidiOutput {
     type Port = MidiOut;
     type Pair = MidiIn;
-    fn name (&self) -> &Arc<str> {
+    fn port_name (&self) -> &Arc<str> {
         &self.name
     }
     fn port (&self) -> &Port<Self::Port> {
@@ -120,7 +124,7 @@ pub trait HasMidiOuts {
         let mut y = 0;
         self.midi_outs().iter().enumerate().map(move|(i, output)|{
             let height = 1 + output.connections().len();
-            let data   = (i, output.name(), output.connections(), y, y + height);
+            let data   = (i, output.port_name(), output.connections(), y, y + height);
             y += height;
             data
         })