tek/crates/engine/src/lib.rs

#![feature(type_alias_impl_trait)]

mod time; pub use self::time::*;
mod note; pub use self::note::*;
pub mod jack; pub use self::jack::*;
pub mod midi; pub use self::midi::*;

pub(crate) use std::sync::{Arc, atomic::{AtomicUsize, AtomicBool, Ordering::Relaxed}};
pub(crate) use std::fmt::Debug;
pub(crate) use std::ops::{Add, Sub, Mul, Div, Rem};

pub(crate) use ::tengri::{from, Usually, Perhaps, Has, tui::*};

pub use ::atomic_float; pub(crate) use atomic_float::*;

//pub trait MaybeHas<T>: Send + Sync {
    //fn get (&self) -> Option<&T>;
//}

//impl<T, U: Has<Option<T>>> MaybeHas<T> for U {
    //fn get (&self) -> Option<&T> {
        //Has::<Option<T>>::get(self).as_ref()
    //}
//}

#[macro_export] macro_rules! has {
    ($T:ty: |$self:ident : $S:ty| $x:expr) => {
        impl Has<$T> for $S {
            fn get     (&$self)     -> &$T     { &$x }
            fn get_mut (&mut $self) -> &mut $T { &mut $x }
        }
    };
}

#[macro_export] macro_rules! as_ref {
    ($T:ty: |$self:ident : $S:ty| $x:expr) => {
        impl AsRef<$T> for $S {
            fn as_ref (&$self) -> &$T { &$x }
        }
    };
}

pub trait HasN<T>: Send + Sync {
    fn get_nth     (&self,     key: usize) -> &T;
    fn get_nth_mut (&mut self, key: usize) -> &mut T;
}

pub trait Gettable<T> {
    /// Returns current value
    fn get (&self) -> T;
}

pub trait Mutable<T>: Gettable<T> {
    /// Sets new value, returns old
    fn set (&mut self, value: T) -> T;
}

pub trait InteriorMutable<T>: Gettable<T> {
    /// Sets new value, returns old
    fn set (&self, value: T) -> T;
}

impl Gettable<bool> for AtomicBool {
    fn get (&self) -> bool { self.load(Relaxed) }
}

impl InteriorMutable<bool> for AtomicBool {
    fn set (&self, value: bool) -> bool { self.swap(value, Relaxed) }
}

impl Gettable<usize> for AtomicUsize {
    fn get (&self) -> usize { self.load(Relaxed) }
}

impl InteriorMutable<usize> for AtomicUsize {
    fn set (&self, value: usize) -> usize { self.swap(value, Relaxed) }
}

#[cfg(test)] #[test] fn test_time () -> Usually<()> {
    // TODO!
    Ok(())
}

#[cfg(test)] #[test] fn test_midi_range () {
    let model = MidiRangeModel::from((1, false));

    let _ = model.get_time_len();
    let _ = model.get_time_zoom();
    let _ = model.get_time_lock();
    let _ = model.get_time_start();
    let _ = model.get_time_axis();
    let _ = model.get_time_end();

    let _ = model.get_note_lo();
    let _ = model.get_note_axis();
    let _ = model.get_note_hi();
}