palette 0.7.7

Convert and manage colors with a focus on correctness, flexibility and ease of use.
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
160
161
162
163
164

//! A collection of named color constants. Can be toggled with the `"named"`
//! Cargo features.
//!
//! They are taken from the [SVG keyword
//! colors](https://www.w3.org/TR/SVG11/types.html#ColorKeywords). These are
//! also part of the CSS3 standard.
//!
//! ```
//! use palette::Srgb;
//! use palette::named;
//!
//! //From constant
//! let from_const = named::OLIVE;
//!
//! //From name string
//! let from_str = named::from_str("olive").expect("unknown color");
//!
//! assert_eq!(from_const, from_str);
//! ```

use core::{fmt, iter::FusedIterator};

pub use codegen::*;

mod codegen;

/// Get an SVG/CSS3 color by name.
///
/// The names are the same as the constants, but lower case.
pub fn from_str(name: &str) -> Option<crate::Srgb<u8>> {
    COLORS.get(name).copied()
}

/// Get an iterator over all SVG/CSS3 names and colors in arbitrary order.
///
/// ```
/// use palette::Srgb;
///
/// let red = Srgb::new(255u8, 0, 0);
///
/// let red_entry = palette::named::entries().find(|(name, color)| *color == red);
/// assert_eq!(red_entry, Some(("red", red)));
/// ```
pub fn entries() -> Entries {
    Entries {
        iter: COLORS.entries(),
    }
}

/// Get an iterator over all SVG/CSS3 color names in arbitrary order.
pub fn names() -> Names {
    Names {
        iter: COLORS.keys(),
    }
}

/// Get an iterator over all SVG/CSS3 color values in arbitrary order.
pub fn colors() -> Colors {
    Colors {
        iter: COLORS.values(),
    }
}

/// An iterator over SVG/CSS3 color entries.
#[derive(Clone)]
pub struct Entries {
    iter: phf::map::Entries<'static, &'static str, crate::Srgb<u8>>,
}

impl fmt::Debug for Entries {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.iter.fmt(f)
    }
}

impl Iterator for Entries {
    type Item = (&'static str, crate::Srgb<u8>);

    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next().map(|(&name, &color)| (name, color))
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }
}

impl DoubleEndedIterator for Entries {
    fn next_back(&mut self) -> Option<Self::Item> {
        self.iter.next_back().map(|(&name, &color)| (name, color))
    }
}

impl ExactSizeIterator for Entries {}

impl FusedIterator for Entries {}

/// An iterator over SVG/CSS3 color names.
#[derive(Clone)]
pub struct Names {
    iter: phf::map::Keys<'static, &'static str, crate::Srgb<u8>>,
}

impl fmt::Debug for Names {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.iter.fmt(f)
    }
}

impl Iterator for Names {
    type Item = &'static str;

    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next().copied()
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }
}

impl DoubleEndedIterator for Names {
    fn next_back(&mut self) -> Option<Self::Item> {
        self.iter.next_back().copied()
    }
}

impl ExactSizeIterator for Names {}

impl FusedIterator for Names {}

/// An iterator over SVG/CSS3 color values.
#[derive(Clone)]
pub struct Colors {
    iter: phf::map::Values<'static, &'static str, crate::Srgb<u8>>,
}

impl fmt::Debug for Colors {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.iter.fmt(f)
    }
}

impl Iterator for Colors {
    type Item = crate::Srgb<u8>;

    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next().copied()
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }
}

impl DoubleEndedIterator for Colors {
    fn next_back(&mut self) -> Option<Self::Item> {
        self.iter.next_back().copied()
    }
}

impl ExactSizeIterator for Colors {}

impl FusedIterator for Colors {}