Struct RGB 

pub struct RGB<T>
where
    T: Channel,
{
    pub red: T,
    pub green: T,
    pub blue: T,
}

Represents a color as red, green and blue channels with no transparency

Fields

red: T

green: T

blue: T

Implementations

impl<T> RGB<T>

where T: Channel,

pub fn try_new(red: T, green: T, blue: T) -> Result<RGB<T>, ColorError>

Creates a new instance

Errors

Returns ColorError::OutsideBoundsNegative if any channel is less than ColorChannel::MIN Returns ColorError::OutsideBoundsHigh if any channel is greater than ColorChannel::MAX

pub fn new(red: T, green: T, blue: T) -> RGB<T>

Creates a new instance infallibly. If any of the arguments are outside of the bounds ColorChannel::MIN and ColorChannel::MAX, that channels value will be either the minimum or the maximum, respectively.

Trait Implementations

impl<T> Clone for RGB<T>

where T: Clone + Channel,

fn clone(&self) -> RGB<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for RGB<T>

where T: Debug + Channel,

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

Formats the value using the given formatter.

impl<T> Default for RGB<T>

where T: Default + Channel,

fn default() -> RGB<T>

Returns the “default value” for a type.

impl<T> Display for RGB<T>

where T: Channel,

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

Formats the value using the given formatter.

impl<T> From<PrimaryColor> for RGB<T>

where T: Channel,

fn from(color: PrimaryColor) -> RGB<T>

Converts to this type from the input type.

impl<T> Hex for RGB<T>

where T: Channel + Hex,

type Err = ColorError

fn to_hex(&self) -> String

Represent a value as a hex string

fn from_hex(hex: &str) -> Result<RGB<T>, <RGB<T> as Hex>::Err>

Convert a hex string to a value

impl<T> PartialEq for RGB<T>

where T: PartialEq + Channel,

fn eq(&self, other: &RGB<T>) -> 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<T> Copy for RGB<T>

where T: Copy + Channel,

impl<T> Eq for RGB<T>

where T: Eq + Channel,

impl<T> StructuralPartialEq for RGB<T>

where T: Channel,