ontv 0.1.3

A rich desktop application for tracking tv shows
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

use std::fmt;
use std::future::Future;

use iced_futures::MaybeSend;
use iced_native::Command;

use crate::commands::Commands;

/// A command buffer used for an application.
pub struct CommandsBuf<M> {
    commands: Vec<Command<M>>,
}

impl<M> CommandsBuf<M> {
    /// Build a single command out of the command buffer.
    pub(crate) fn build(&mut self) -> Command<M> {
        if self.commands.is_empty() {
            return Command::none();
        }

        Command::batch(self.commands.drain(..))
    }
}

impl<M> Commands<M> for CommandsBuf<M> {
    type ByRef<'this> = &'this mut Self where Self: 'this;

    #[inline]
    fn by_ref(&mut self) -> Self::ByRef<'_> {
        self
    }

    #[inline]
    fn perform<F>(&mut self, future: F, map: impl Fn(F::Output) -> M + MaybeSend + 'static)
    where
        F: Future + 'static + MaybeSend,
    {
        self.commands.push(Command::perform(future, map));
    }

    #[inline]
    fn command(&mut self, command: Command<M>) {
        self.commands.push(command);
    }
}

impl<M> Default for CommandsBuf<M> {
    #[inline]
    fn default() -> Self {
        Self {
            commands: Vec::new(),
        }
    }
}

impl<M> fmt::Debug for CommandsBuf<M>
where
    M: fmt::Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LocalCommands")
            .field("commands", &self.commands)
            .finish_non_exhaustive()
    }
}