Struct Palette

pub struct Palette<Key: Ord, Value> {
    pub values: Vec<Value>,
    pub selectors: BTreeMap<Key, Selector<Value>>,
}

A palette of any kind. It stores values (often colors or gradients) that are accessible by index or by key.

Fields

values: Vec<Value>

Available default palette values. Used in a carousel fashion for large amounts of keys. I.e. the number of keys is greater than the number of values.

selectors: BTreeMap<Key, Selector<Value>>

Field keys to color selectors (indices or overrides).

Implementations

impl<Key: Ord, Value> Palette<Key, Value>

pub fn new<Values>( values: Values, selectors: BTreeMap<Key, Selector<Value>>, ) -> Self

where Values: IntoIterator<Item = Value>,

Create a new palette with values and a selectors mapping. See key_to_order to create a default mapping for keys that will map to their key’s order in the map.

Trait Implementations

impl<Key: Clone + Ord, Value: Clone> Clone for Palette<Key, Value>

fn clone(&self) -> Palette<Key, Value>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Key: Ord, Color> Container for Palette<Key, Color>

type Key = Key

type Value = Color

fn values(&self) -> &[Self::Value]

The slice of values that are used by default.

fn selectors(&self) -> &BTreeMap<Self::Key, Selector<Self::Value>>

The mapping of key to selector. A selector is an entry’s index or an override.

fn with_preset<V, P>( preset: &P, selectors: BTreeMap<Self::Key, Selector<Self::Value>>, ) -> Self

where V: Into<Self::Value>, P: Preset<Value = V>,

Create this palette from a preset.

fn with_presets<V, P>( presets: &[P], selectors: BTreeMap<Self::Key, Selector<Self::Value>>, ) -> Self

where V: Into<Self::Value>, P: Preset<Value = V>,

fn len(&self) -> usize

The number of values of the (non-override) values.

fn is_empty(&self) -> bool

Whether the values are empty.

fn by_index(&self, index: usize) -> Option<&Self::Value>

Get a value by index. Index undergoes modulo operation such that values are used in a carousel fashion by default.

fn get<K: Into<Self::Key>>(&self, key: K) -> Option<&Self::Value>

where Self::Key: Ord,

Get a value by key.

impl<Key: Debug + Ord, Value: Debug> Debug for Palette<Key, Value>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Key: Default + Ord, Value: Default> Default for Palette<Key, Value>

fn default() -> Palette<Key, Value>

Returns the “default value” for a type.

impl<'de, Key, Value> Deserialize<'de> for Palette<Key, Value>

where Key: Deserialize<'de> + Ord, Value: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Key: PartialEq + Ord, Value: PartialEq> PartialEq for Palette<Key, Value>

fn eq(&self, other: &Palette<Key, Value>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Key, Value> Serialize for Palette<Key, Value>

where Key: Serialize + Ord, Value: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Key: Ord, Value> StructuralPartialEq for Palette<Key, Value>