transport -> clock

src/clock/clock_tui.rs

@@ -0,0 +1,149 @@
+use crate::*;
+use ClockCommand::{Play, Pause, SetBpm, SetQuant, SetSync};
+use FocusCommand::{Next, Prev};
+use KeyCode::{Enter, Left, Right, Char};
+
+/// Transport clock app.
+pub struct TransportTui {
+    pub jack:   Arc<RwLock<JackConnection>>,
+    pub clock:  Clock,
+    pub size:   Measure<Tui>,
+    pub cursor: (usize, usize),
+    pub color:  ItemPalette,
+}
+from_jack!(|jack|TransportTui Self {
+    jack:   jack.clone(),
+    clock:  Clock::from(jack),
+    size:   Measure::new(),
+    cursor: (0, 0),
+    color:  ItemPalette::random(),
+});
+has_clock!(|self: TransportTui|&self.clock);
+audio!(|self: TransportTui, client, scope|ClockAudio(self).process(client, scope));
+handle!(<Tui>|self: TransportTui, from|TransportCommand::execute_with_state(self, from));
+render!(Tui: (self: TransportTui) => TransportView(&self.clock));
+
+pub struct TransportView<'a>(pub &'a Clock);
+render!(Tui: (self: TransportView<'a>) => row!(
+    BeatStats::new(self.0), " ",
+    PlayPause(self.0.is_rolling()), " ",
+    OutputStats::new(self.0),
+));
+
+pub struct PlayPause(pub bool);
+render!(Tui: (self: PlayPause) => Tui::bg(
+    if self.0{Color::Rgb(0,128,0)}else{Color::Rgb(128,64,0)},
+    Fixed::x(5, Tui::either(self.0,
+        Tui::fg(Color::Rgb(0, 255, 0),   Bsp::s(" 🭍🭑🬽 ", " 🭞🭜🭘 ",)),
+        Tui::fg(Color::Rgb(255, 128, 0), Bsp::s(" ▗▄▖ ", " ▝▀▘ ",))))));
+impl std::fmt::Debug for TransportTui {
+    fn fmt (&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        f.debug_struct("TransportTui")
+            .field("jack",   &self.jack)
+            .field("size",   &self.size)
+            .field("cursor", &self.cursor)
+            .finish()
+    }
+}
+
+pub struct BeatStats { bpm: String, beat: String, time: String, }
+impl BeatStats {
+    fn new (clock: &Clock) -> Self {
+        let (beat, time) = clock.started.read().unwrap().as_ref().map(|started|{
+            let current_usec = clock.global.usec.get() - started.usec.get();
+            (
+                clock.timebase.format_beats_1(clock.timebase.usecs_to_pulse(current_usec)),
+                format!("{:.3}s", current_usec/1000000.)
+            )
+        }).unwrap_or_else(||("-.-.--".to_string(), "-.---s".to_string()));
+        Self { bpm: format!("{:.3}", clock.timebase.bpm.get()), beat, time }
+    }
+}
+render!(Tui: (self: BeatStats) => col!(
+    Bsp::e(&self.bpm, " BPM"), Bsp::e("Beat ", &self.beat), Bsp::e("Time ", &self.time),
+));
+
+pub struct OutputStats { sample_rate: String, buffer_size: String, latency: String, }
+impl OutputStats {
+    fn new (clock: &Clock) -> Self {
+        let rate  = clock.timebase.sr.get();
+        let chunk = clock.chunk.load(Relaxed);
+        Self {
+            sample_rate: format!("{:.1}Hz", rate),
+            buffer_size: format!("{chunk}"),
+            latency:     format!("{}", chunk as f64 / rate * 1000.),
+        }
+    }
+}
+render!(Tui: (self: OutputStats) => col!(
+    Bsp::e(format!("{}", self.sample_rate), " sample rate"),
+    Bsp::e(format!("{}", self.buffer_size), " sample buffer"),
+    Bsp::e(format!("{:.3}ms", self.latency), " latency"),
+));
+#[derive(Clone, Debug, PartialEq)]
+pub enum TransportCommand {
+    Clock(ClockCommand),
+}
+command!(|self:TransportCommand,state:TransportTui|match self {
+    //Self::Focus(cmd) => cmd.execute(state)?.map(Self::Focus),
+    Self::Clock(cmd) => cmd.execute(state)?.map(Self::Clock),
+    _ => unreachable!(),
+});
+impl InputToCommand<Tui, TransportTui> for TransportCommand {
+    fn input_to_command (state: &TransportTui, input: &TuiIn) -> Option<Self> {
+        use TransportCommand::*;
+        Some(match input.event() {
+            key_pat!(Char(' ')) => Clock(if state.clock().is_stopped() {
+                Play(None)
+            } else {
+                Pause(None)
+            }),
+            key_pat!(Shift-Char(' ')) => Clock(if state.clock().is_stopped() {
+                Play(Some(0))
+            } else {
+                Pause(Some(0))
+            }),
+            _ => return None
+        })
+    }
+}
+fn to_bpm_command (input: &TuiIn, bpm: f64) -> Option<TransportCommand> {
+    use TransportCommand::*;
+    Some(match input.event() {
+        key_pat!(Char(',')) => Clock(SetBpm(bpm - 1.0)),
+        key_pat!(Char('.')) => Clock(SetBpm(bpm + 1.0)),
+        key_pat!(Char('<')) => Clock(SetBpm(bpm - 0.001)),
+        key_pat!(Char('>')) => Clock(SetBpm(bpm + 0.001)),
+        _ => return None,
+    })
+}
+fn to_quant_command (input: &TuiIn, quant: &Quantize) -> Option<TransportCommand> {
+    use TransportCommand::*;
+    Some(match input.event() {
+        key_pat!(Char(',')) => Clock(SetQuant(quant.prev())),
+        key_pat!(Char('.')) => Clock(SetQuant(quant.next())),
+        key_pat!(Char('<')) => Clock(SetQuant(quant.prev())),
+        key_pat!(Char('>')) => Clock(SetQuant(quant.next())),
+        _ => return None,
+    })
+}
+fn to_sync_command (input: &TuiIn, sync: &LaunchSync) -> Option<TransportCommand> {
+    use TransportCommand::*;
+    Some(match input.event() {
+        key_pat!(Char(',')) => Clock(SetSync(sync.prev())),
+        key_pat!(Char('.')) => Clock(SetSync(sync.next())),
+        key_pat!(Char('<')) => Clock(SetSync(sync.prev())),
+        key_pat!(Char('>')) => Clock(SetSync(sync.next())),
+        _ => return None,
+    })
+}
+fn to_seek_command (input: &TuiIn) -> Option<TransportCommand> {
+    use TransportCommand::*;
+    Some(match input.event() {
+        key_pat!(Char(',')) => todo!("transport seek bar"),
+        key_pat!(Char('.')) => todo!("transport seek bar"),
+        key_pat!(Char('<')) => todo!("transport seek beat"),
+        key_pat!(Char('>')) => todo!("transport seek beat"),
+        _ => return None,
+    })
+}

src/clock/microsecond.rs

@@ -0,0 +1,15 @@
+use crate::*;
+
+/// Timestamp in microseconds
+#[derive(Debug, Default)] pub struct Microsecond(AtomicF64);
+
+impl_time_unit!(Microsecond);
+
+impl Microsecond {
+    #[inline] pub fn format_msu (&self) -> String {
+        let usecs              = self.get() as usize;
+        let (seconds, msecs)   = (usecs / 1000000, usecs / 1000 % 1000);
+        let (minutes, seconds) = (seconds / 60, seconds % 60);
+        format!("{minutes}:{seconds:02}:{msecs:03}")
+    }
+}

src/clock/moment.rs

@@ -0,0 +1,70 @@
+use crate::*;
+
+#[derive(Debug, Clone)]
+pub enum Moment2 {
+    None,
+    Zero,
+    Usec(Microsecond),
+    Sample(SampleCount),
+    Pulse(Pulse),
+}
+
+/// A point in time in all time scales (microsecond, sample, MIDI pulse)
+#[derive(Debug, Default, Clone)]
+pub struct Moment {
+    pub timebase: Arc<Timebase>,
+    /// Current time in microseconds
+    pub usec:   Microsecond,
+    /// Current time in audio samples
+    pub sample: SampleCount,
+    /// Current time in MIDI pulses
+    pub pulse:  Pulse,
+}
+
+impl Moment {
+    pub fn zero (timebase: &Arc<Timebase>) -> Self {
+        Self { usec: 0.into(), sample: 0.into(), pulse: 0.into(), timebase: timebase.clone() }
+    }
+    pub fn from_usec (timebase: &Arc<Timebase>, usec: f64) -> Self {
+        Self {
+            usec:     usec.into(),
+            sample:   timebase.sr.usecs_to_sample(usec).into(),
+            pulse:    timebase.usecs_to_pulse(usec).into(),
+            timebase: timebase.clone(),
+        }
+    }
+    pub fn from_sample (timebase: &Arc<Timebase>, sample: f64) -> Self {
+        Self {
+            sample:   sample.into(),
+            usec:     timebase.sr.samples_to_usec(sample).into(),
+            pulse:    timebase.samples_to_pulse(sample).into(),
+            timebase: timebase.clone(),
+        }
+    }
+    pub fn from_pulse (timebase: &Arc<Timebase>, pulse: f64) -> Self {
+        Self {
+            pulse:    pulse.into(),
+            sample:   timebase.pulses_to_sample(pulse).into(),
+            usec:     timebase.pulses_to_usec(pulse).into(),
+            timebase: timebase.clone(),
+        }
+    }
+    #[inline] pub fn update_from_usec (&self, usec: f64) {
+        self.usec.set(usec);
+        self.pulse.set(self.timebase.usecs_to_pulse(usec));
+        self.sample.set(self.timebase.sr.usecs_to_sample(usec));
+    }
+    #[inline] pub fn update_from_sample (&self, sample: f64) {
+        self.usec.set(self.timebase.sr.samples_to_usec(sample));
+        self.pulse.set(self.timebase.samples_to_pulse(sample));
+        self.sample.set(sample);
+    }
+    #[inline] pub fn update_from_pulse (&self, pulse: f64) {
+        self.usec.set(self.timebase.pulses_to_usec(pulse));
+        self.pulse.set(pulse);
+        self.sample.set(self.timebase.pulses_to_sample(pulse));
+    }
+    #[inline] pub fn format_beat (&self) -> String {
+        self.timebase.format_beats_1(self.pulse.get())
+    }
+}

src/clock/perf.rs

@@ -0,0 +1,58 @@
+use crate::*;
+
+/// Performance counter
+pub struct PerfModel {
+    pub enabled: bool,
+    clock:  quanta::Clock,
+    // In nanoseconds
+    used:   AtomicF64,
+    // In microseconds
+    period: AtomicF64,
+}
+
+pub trait HasPerf {
+    fn perf (&self) -> &PerfModel;
+}
+
+impl Default for PerfModel {
+    fn default () -> Self {
+        Self {
+            enabled: true,
+            clock:   quanta::Clock::new(),
+            used:    Default::default(),
+            period:  Default::default(),
+        }
+    }
+}
+
+impl PerfModel {
+    pub fn get_t0 (&self) -> Option<u64> {
+        if self.enabled {
+            Some(self.clock.raw())
+        } else {
+            None
+        }
+    }
+    pub fn update (&self, t0: Option<u64>, scope: &ProcessScope) {
+        if let Some(t0) = t0 {
+            let t1 = self.clock.raw();
+            self.used.store(
+                self.clock.delta_as_nanos(t0, t1) as f64,
+                Relaxed,
+            );
+            self.period.store(
+                scope.cycle_times().unwrap().period_usecs as f64,
+                Relaxed,
+            );
+        }
+    }
+    pub fn percentage (&self) -> Option<f64> {
+        let period = self.period.load(Relaxed) * 1000.0;
+        if period > 0.0 {
+            let used = self.used.load(Relaxed);
+            Some(100.0 * used / period)
+        } else {
+            None
+        }
+    }
+}

src/clock/pulse.rs

@@ -0,0 +1,71 @@
+use crate::*;
+
+pub const DEFAULT_PPQ: f64 = 96.0;
+
+/// FIXME: remove this and use PPQ from timebase everywhere:
+pub const PPQ: usize = 96;
+
+/// MIDI resolution in PPQ (pulses per quarter note)
+#[derive(Debug, Default)] pub struct PulsesPerQuaver(AtomicF64);
+impl_time_unit!(PulsesPerQuaver);
+
+/// Timestamp in MIDI pulses
+#[derive(Debug, Default)] pub struct Pulse(AtomicF64);
+impl_time_unit!(Pulse);
+
+/// Tempo in beats per minute
+#[derive(Debug, Default)] pub struct BeatsPerMinute(AtomicF64);
+impl_time_unit!(BeatsPerMinute);
+
+/// Quantization setting for launching clips
+#[derive(Debug, Default)] pub struct LaunchSync(AtomicF64);
+impl_time_unit!(LaunchSync);
+impl LaunchSync {
+    pub fn next (&self) -> f64 {
+        Note::next(self.get() as usize) as f64
+    }
+    pub fn prev (&self) -> f64 {
+        Note::prev(self.get() as usize) as f64
+    }
+}
+
+/// Quantization setting for notes
+#[derive(Debug, Default)] pub struct Quantize(AtomicF64);
+impl_time_unit!(Quantize);
+impl Quantize {
+    pub fn next (&self) -> f64 {
+        Note::next(self.get() as usize) as f64
+    }
+    pub fn prev (&self) -> f64 {
+        Note::prev(self.get() as usize) as f64
+    }
+}
+
+/// Iterator that emits subsequent ticks within a range.
+pub struct TicksIterator {
+    pub spp:    f64,
+    pub sample: usize,
+    pub start:  usize,
+    pub end:    usize,
+}
+impl Iterator for TicksIterator {
+    type Item = (usize, usize);
+    fn next (&mut self) -> Option<Self::Item> {
+        loop {
+            if self.sample > self.end { return None }
+            let spp    = self.spp;
+            let sample = self.sample as f64;
+            let start  = self.start;
+            let end    = self.end;
+            self.sample += 1;
+            //println!("{spp} {sample} {start} {end}");
+            let jitter = sample.rem_euclid(spp); // ramps
+            let next_jitter = (sample + 1.0).rem_euclid(spp);
+            if jitter > next_jitter { // at crossing:
+                let time = (sample as usize) % (end as usize-start as usize);
+                let tick = (sample / spp) as usize;
+                return Some((time, tick))
+            }
+        }
+    }
+}

src/clock/sample_count.rs

@@ -0,0 +1,5 @@
+use crate::*;
+
+/// Timestamp in audio samples
+#[derive(Debug, Default)] pub struct SampleCount(AtomicF64);
+impl_time_unit!(SampleCount);

src/clock/sample_rate.rs

@@ -0,0 +1,23 @@
+use crate::*;
+
+/// Audio sample rate in Hz (samples per second)
+#[derive(Debug, Default)] pub struct SampleRate(AtomicF64);
+impl_time_unit!(SampleRate);
+impl SampleRate {
+    /// Return the duration of a sample in microseconds (floating)
+    #[inline] pub fn usec_per_sample (&self) -> f64 {
+        1_000_000f64 / self.get()
+    }
+    /// Return the duration of a sample in microseconds (floating)
+    #[inline] pub fn sample_per_usec (&self) -> f64 {
+        self.get() / 1_000_000f64
+    }
+    /// Convert a number of samples to microseconds (floating)
+    #[inline] pub fn samples_to_usec (&self, samples: f64) -> f64 {
+        self.usec_per_sample() * samples
+    }
+    /// Convert a number of microseconds to samples (floating)
+    #[inline] pub fn usecs_to_sample (&self, usecs:   f64) -> f64 {
+        self.sample_per_usec() * usecs
+    }
+}

src/clock/timebase.rs

@@ -0,0 +1,112 @@
+use crate::*;
+
+/// Temporal resolutions: sample rate, tempo, MIDI pulses per quaver (beat)
+#[derive(Debug, Clone)]
+pub struct Timebase {
+    /// Audio samples per second
+    pub sr:  SampleRate,
+    /// MIDI beats per minute
+    pub bpm: BeatsPerMinute,
+    /// MIDI ticks per beat
+    pub ppq: PulsesPerQuaver,
+}
+
+impl Timebase {
+    /// Specify sample rate, BPM and PPQ
+    pub fn new (
+        s: impl Into<SampleRate>,
+        b: impl Into<BeatsPerMinute>,
+        p: impl Into<PulsesPerQuaver>
+    ) -> Self {
+        Self { sr: s.into(), bpm: b.into(), ppq: p.into() }
+    }
+    /// Iterate over ticks between start and end.
+    #[inline] pub fn pulses_between_samples (&self, start: usize, end: usize) -> TicksIterator {
+        TicksIterator { spp: self.samples_per_pulse(), sample: start, start, end }
+    }
+    /// Return the duration fo a beat in microseconds
+    #[inline] pub fn usec_per_beat (&self) -> f64 { 60_000_000f64 / self.bpm.get() }
+    /// Return the number of beats in a second
+    #[inline] pub fn beat_per_second (&self) -> f64 { self.bpm.get() / 60f64 }
+    /// Return the number of microseconds corresponding to a note of the given duration
+    #[inline] pub fn note_to_usec (&self, (num, den): (f64, f64)) -> f64 {
+        4.0 * self.usec_per_beat() * num / den
+    }
+    /// Return duration of a pulse in microseconds (BPM-dependent)
+    #[inline] pub fn pulse_per_usec (&self) -> f64 { self.ppq.get() / self.usec_per_beat() }
+    /// Return duration of a pulse in microseconds (BPM-dependent)
+    #[inline] pub fn usec_per_pulse (&self) -> f64 { self.usec_per_beat() / self.ppq.get() }
+    /// Return number of pulses to which a number of microseconds corresponds (BPM-dependent)
+    #[inline] pub fn usecs_to_pulse (&self, usec: f64) -> f64 { usec * self.pulse_per_usec() }
+    /// Convert a number of pulses to a sample number (SR- and BPM-dependent)
+    #[inline] pub fn pulses_to_usec (&self, pulse: f64) -> f64 { pulse / self.usec_per_pulse() }
+    /// Return number of pulses in a second (BPM-dependent)
+    #[inline] pub fn pulses_per_second (&self) -> f64 { self.beat_per_second() * self.ppq.get() }
+    /// Return fraction of a pulse to which a sample corresponds (SR- and BPM-dependent)
+    #[inline] pub fn pulses_per_sample (&self) -> f64 {
+        self.usec_per_pulse() / self.sr.usec_per_sample()
+    }
+    /// Return number of samples in a pulse (SR- and BPM-dependent)
+    #[inline] pub fn samples_per_pulse (&self) -> f64 {
+        self.sr.get() / self.pulses_per_second()
+    }
+    /// Convert a number of pulses to a sample number (SR- and BPM-dependent)
+    #[inline] pub fn pulses_to_sample (&self, p: f64) -> f64 {
+        self.pulses_per_sample() * p
+    }
+    /// Convert a number of samples to a pulse number (SR- and BPM-dependent)
+    #[inline] pub fn samples_to_pulse (&self, s: f64) -> f64 {
+        s / self.pulses_per_sample()
+    }
+    /// Return the number of samples corresponding to a note of the given duration
+    #[inline] pub fn note_to_samples (&self, note: (f64, f64)) -> f64 {
+        self.usec_to_sample(self.note_to_usec(note))
+    }
+    /// Return the number of samples corresponding to the given number of microseconds
+    #[inline] pub fn usec_to_sample (&self, usec: f64) -> f64 {
+        usec * self.sr.get() / 1000f64
+    }
+    /// Return the quantized position of a moment in time given a step
+    #[inline] pub fn quantize (&self, step: (f64, f64), time: f64) -> (f64, f64) {
+        let step = self.note_to_usec(step);
+        (time / step, time % step)
+    }
+    /// Quantize a collection of events
+    #[inline] pub fn quantize_into <E: Iterator<Item=(f64, f64)> + Sized, T> (
+        &self, step: (f64, f64), events: E
+    ) -> Vec<(f64, f64)> {
+        events.map(|(time, event)|(self.quantize(step, time).0, event)).collect()
+    }
+    /// Format a number of pulses into Beat.Bar.Pulse starting from 0
+    #[inline] pub fn format_beats_0 (&self, pulse: f64) -> String {
+        let pulse = pulse as usize;
+        let ppq   = self.ppq.get() as usize;
+        let (beats, pulses) = if ppq > 0 { (pulse / ppq, pulse % ppq) } else { (0, 0) };
+        format!("{}.{}.{pulses:02}", beats / 4, beats % 4)
+    }
+    /// Format a number of pulses into Beat.Bar starting from 0
+    #[inline] pub fn format_beats_0_short (&self, pulse: f64) -> String {
+        let pulse = pulse as usize;
+        let ppq   = self.ppq.get() as usize;
+        let beats = if ppq > 0 { pulse / ppq } else { 0 };
+        format!("{}.{}", beats / 4, beats % 4)
+    }
+    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
+    #[inline] pub fn format_beats_1 (&self, pulse: f64) -> String {
+        let pulse = pulse as usize;
+        let ppq   = self.ppq.get() as usize;
+        let (beats, pulses) = if ppq > 0 { (pulse / ppq, pulse % ppq) } else { (0, 0) };
+        format!("{}.{}.{pulses:02}", beats / 4 + 1, beats % 4 + 1)
+    }
+    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
+    #[inline] pub fn format_beats_1_short (&self, pulse: f64) -> String {
+        let pulse = pulse as usize;
+        let ppq   = self.ppq.get() as usize;
+        let beats = if ppq > 0 { pulse / ppq } else { 0 };
+        format!("{}.{}", beats / 4 + 1, beats % 4 + 1)
+    }
+}
+
+impl Default for Timebase {
+    fn default () -> Self { Self::new(48000f64, 150f64, DEFAULT_PPQ) }
+}

src/clock/unit.rs

@@ -0,0 +1,59 @@
+use crate::*;
+
+/// A unit of time, represented as an atomic 64-bit float.
+///
+/// According to https://stackoverflow.com/a/873367, as per IEEE754,
+/// every integer between 1 and 2^53 can be represented exactly.
+/// This should mean that, even at 192kHz sampling rate, over 1 year of audio
+/// can be clocked in microseconds with f64 without losing precision.
+pub trait TimeUnit: InteriorMutable<f64> {}
+
+/// Implement an arithmetic operation for a unit of time
+#[macro_export] macro_rules! impl_op {
+    ($T:ident, $Op:ident, $method:ident, |$a:ident,$b:ident|{$impl:expr}) => {
+        impl $Op<Self> for $T {
+            type Output = Self; #[inline] fn $method (self, other: Self) -> Self::Output {
+                let $a = self.get(); let $b = other.get(); Self($impl.into())
+            }
+        }
+        impl $Op<usize> for $T {
+            type Output = Self; #[inline] fn $method (self, other: usize) -> Self::Output {
+                let $a = self.get(); let $b = other as f64; Self($impl.into())
+            }
+        }
+        impl $Op<f64> for $T {
+            type Output = Self; #[inline] fn $method (self, other: f64) -> Self::Output {
+                let $a = self.get(); let $b = other; Self($impl.into())
+            }
+        }
+    }
+}
+
+/// Define and implement a unit of time
+#[macro_export] macro_rules! impl_time_unit {
+    ($T:ident) => {
+        impl Gettable<f64> for $T {
+            fn get (&self) -> f64 { self.0.load(Relaxed) }
+        }
+        impl InteriorMutable<f64> for $T {
+            fn set (&self, value: f64) -> f64 {
+                let old = self.get();
+                self.0.store(value, Relaxed);
+                old
+            }
+        }
+        impl TimeUnit for $T {}
+        impl_op!($T, Add, add, |a, b|{a + b});
+        impl_op!($T, Sub, sub, |a, b|{a - b});
+        impl_op!($T, Mul, mul, |a, b|{a * b});
+        impl_op!($T, Div, div, |a, b|{a / b});
+        impl_op!($T, Rem, rem, |a, b|{a % b});
+        impl From<f64>   for $T    { fn from (value: f64)   -> Self { Self(value.into()) } }
+        impl From<usize> for $T    { fn from (value: usize) -> Self { Self((value as f64).into()) } }
+        impl From<$T>    for f64   { fn from (value: $T)    -> Self { value.get() } }
+        impl From<$T>    for usize { fn from (value: $T)    -> Self { value.get() as usize } }
+        impl From<&$T>   for f64   { fn from (value: &$T)   -> Self { value.get() } }
+        impl From<&$T>   for usize { fn from (value: &$T)   -> Self { value.get() as usize } }
+        impl Clone for $T { fn clone (&self) -> Self { Self(self.get().into()) } }
+    }
+}