euphony 0.1.1

music composition environment for programmers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use crate::{group::Grouped, output};
use bach::executor::{Environment, Executor, Handle};
use core::{future::Future, task::Poll};
use euphony_units::time::Tempo;

pub use bach::{executor::JoinHandle, rand};

pub mod primary {
    use super::*;
    pub use bach::task::primary::*;

    pub fn spawn<F: 'static + Future<Output = T> + Send, T: 'static + Send>(
        future: F,
    ) -> JoinHandle<T> {
        // try to inherit the parent group
        crate::group::scope::try_borrow_with(|group| {
            if let Some(group) = group {
                bach::task::primary::spawn(Grouped::new(future, *group))
            } else {
                bach::task::primary::spawn(future)
            }
        })
    }
}

pub fn spawn<F: 'static + Future<Output = T> + Send, T: 'static + Send>(
    future: F,
) -> JoinHandle<T> {
    // try to inherit the parent group
    crate::group::scope::try_borrow_with(|group| {
        if let Some(group) = group {
            bach::task::spawn(Grouped::new(future, *group))
        } else {
            bach::task::spawn(future)
        }
    })
}

pub struct Runtime {
    executor: Executor<Env>,
}

impl Runtime {
    pub fn from_env() -> Self {
        let args = crate::args::Args::from_args();

        if let Some(tempo) = args.tempo {
            let tempo = Tempo(tempo, 1);
            crate::time::set_tempo(tempo);
        }

        if let Some(path) = args.output.as_ref() {
            if path.to_str() != Some("-") {
                output::set_file(path);
            } else {
                // setting the output argument forces binary mode
                output::set_stdout();
            }
        }

        let seed = if let Some(seed) = args.seed {
            seed
        } else {
            *crate::rand::SEED
        };

        Self::new(seed)
    }

    pub fn new(seed: u64) -> Self {
        let executor = Executor::new(|handle| Env::new(handle, seed));
        Self { executor }
    }

    pub fn block_on<F, Output>(&mut self, task: F) -> Output
    where
        F: 'static + Future<Output = Output> + Send,
        Output: 'static + Send,
    {
        let result = self.executor.block_on(task);

        // finish any primary tasks
        self.executor.block_on_primary();

        output::finish();

        result
    }
}

struct Env {
    scheduler: crate::time::Scheduler,
    handle: Handle,
    rand: crate::rand::Scope,
}

impl Env {
    fn new(handle: &Handle, seed: u64) -> Self {
        let scheduler = crate::time::Scheduler::new();
        let rand = crate::rand::Scope::new(seed);

        Self {
            scheduler,
            handle: handle.clone(),
            rand,
        }
    }
}

impl Environment for Env {
    fn run<Tasks, F>(&mut self, tasks: Tasks) -> Poll<()>
    where
        Tasks: Iterator<Item = F> + Send,
        F: 'static + FnOnce() -> Poll<()> + Send,
    {
        let mut is_ready = true;

        let Self {
            ref scheduler,
            ref handle,
            ref rand,
        } = self;

        handle.enter(|| {
            scheduler.enter(|| {
                rand.enter(|| {
                    for task in tasks {
                        is_ready &= task().is_ready();
                    }
                })
            })
        });

        if is_ready {
            Poll::Ready(())
        } else {
            Poll::Pending
        }
    }

    fn on_macrostep(&mut self, count: usize) {
        // wait until all tasks settle before waking the timer
        if count > 0 {
            return;
        }

        let mut advance = 0;
        while let Some(ticks) = self.scheduler.advance() {
            advance += ticks;
            if self.scheduler.wake() > 0 {
                break;
            }
        }

        if advance > 0 {
            output::advance_time(advance);
        }
    }
}