aura-anim-iced 0.1.1

Iced-first animation primitives.
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

use std::num::NonZeroU32;

/// Iteration configuration for a timing value.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct IterationCount {
    kind: IterationCountKind,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum IterationCountKind {
    Count(NonZeroU32),
    Infinite,
}

impl IterationCount {
    /// A single animation iteration.
    pub const ONCE: Self = Self {
        kind: IterationCountKind::Count(NonZeroU32::MIN),
    };

    /// An infinite number of iterations.
    pub const INFINITE: Self = Self {
        kind: IterationCountKind::Infinite,
    };

    /// Creates a finite iteration count, clamped to at least one iteration.
    #[must_use]
    pub fn count(count: u32) -> Self {
        let count = NonZeroU32::new(count).unwrap_or(NonZeroU32::MIN);

        Self {
            kind: IterationCountKind::Count(count),
        }
    }

    /// Returns an infinite iteration count.
    #[must_use]
    pub const fn infinite() -> Self {
        Self::INFINITE
    }

    /// Returns the finite count when this value is not infinite.
    #[must_use]
    pub const fn finite_count(self) -> Option<u32> {
        match self.kind {
            IterationCountKind::Count(count) => Some(count.get()),
            IterationCountKind::Infinite => None,
        }
    }
}

impl Default for IterationCount {
    fn default() -> Self {
        Self::ONCE
    }
}

impl From<u32> for IterationCount {
    fn from(value: u32) -> Self {
        Self::count(value)
    }
}