# EncodedBt2020 in maplibre::style - Rust
A color in the encoded BT.2020 color space.
Keywords: rust, rustlang, rust-lang, EncodedBt2020

# Struct maplibre::style::EncodedBt2020

[−]

    #[repr(C)]pub struct EncodedBt2020<ComponentTy> {
        pub r: ComponentTy,
        pub g: ComponentTy,
        pub b: ComponentTy,
    }

Expand description

A color in the encoded BT.2020 color space.

This color space uses the BT.2020 primaries and D65 white point and the BT.2020 transfer functions (equivalent to BT.601 transfer functions but with higher precision). This encoded version is nonlinear, with the BT.2020/BT.601 OETF applied.

## Fields

`r: ComponentTy`

The red component.

`g: ComponentTy`

The green component.

`b: ComponentTy`

The blue component.

## Trait Implementations

### impl<ComponentTy> AsRef<[ComponentTy; 3]> for EncodedBt2020<ComponentTy>

#### pub fn as_ref(&self) -> &[ComponentTy; 3]

Performs the conversion.

### impl<ComponentTy> Clone for EncodedBt2020<ComponentTy> where
ComponentTy: Clone,

#### pub fn clone(&self) -> EncodedBt2020<ComponentTy>

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from `source`. Read more

### impl<CTy> ColorStruct for EncodedBt2020<CTy> where
CTy: Clone + Copy,

#### type ComponentTy = CTy

### impl<ComponentTy> Debug for EncodedBt2020<ComponentTy> where
ComponentTy: Debug,

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

Formats the value using the given formatter. Read more

### impl<ComponentTy> From<[ComponentTy; 3]> for EncodedBt2020<ComponentTy>

#### pub fn from([ComponentTy; 3]) -> EncodedBt2020<ComponentTy>

Performs the conversion.

### impl<ComponentTy> From<Alpha<EncodedBt2020<ComponentTy>>> for EncodedBt2020<ComponentTy> where
ComponentTy: Clone + Copy,

#### pub fn from(
col_alpha: Alpha<EncodedBt2020<ComponentTy>>
) -> EncodedBt2020<ComponentTy>

Performs the conversion.

### impl<ComponentTy> From<PremultipliedAlpha<EncodedBt2020<ComponentTy>>> for EncodedBt2020<ComponentTy> where
ComponentTy: Clone + Copy,

#### pub fn from(
col_alpha: PremultipliedAlpha<EncodedBt2020<ComponentTy>>
) -> EncodedBt2020<ComponentTy>

Performs the conversion.

### impl<ComponentTy> Hash for EncodedBt2020<ComponentTy> where
ComponentTy: Hash,

#### pub fn hash<__H>(&self, state: &mut __H) where
__H: Hasher,

Feeds this value into the given `Hasher`. Read more

1.3.0 · source

#### fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,

Feeds a slice of this type into the given `Hasher`. Read more

### impl<ComponentTy> Into<[ComponentTy; 3]> for EncodedBt2020<ComponentTy>

#### pub fn into(self) -> [ComponentTy; 3]

Performs the conversion.

### impl<ComponentTy> Ord for EncodedBt2020<ComponentTy> where
ComponentTy: Ord,

#### pub fn cmp(&self, other: &EncodedBt2020<ComponentTy>) -> Ordering

This method returns an `Ordering` between `self` and `other`. Read more

1.21.0 · source

#### fn max(self, other: Self) -> Self

Compares and returns the maximum of two values. Read more

1.21.0 · source

#### fn min(self, other: Self) -> Self

Compares and returns the minimum of two values. Read more

1.50.0 · source

#### fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval. Read more

### impl<ComponentTy> PartialEq<EncodedBt2020<ComponentTy>> for EncodedBt2020<ComponentTy> where
ComponentTy: PartialEq<ComponentTy>,

#### pub fn eq(&self, other: &EncodedBt2020<ComponentTy>) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### pub fn ne(&self, other: &EncodedBt2020<ComponentTy>) -> bool

This method tests for `!=`.

### impl<ComponentTy> PartialOrd<EncodedBt2020<ComponentTy>> for EncodedBt2020<ComponentTy> where
ComponentTy: PartialOrd<ComponentTy>,

#### pub fn partial_cmp(
&self,
other: &EncodedBt2020<ComponentTy>
) -> Option<Ordering>

This method returns an ordering between `self` and `other` values if one exists. Read more

1.0.0 · source

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

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

1.0.0 · source

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

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

1.0.0 · source

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

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

1.0.0 · source

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

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### impl<ComponentTy> Copy for EncodedBt2020<ComponentTy> where
ComponentTy: Copy,

### impl<ComponentTy> Eq for EncodedBt2020<ComponentTy> where
ComponentTy: Eq,

### impl<ComponentTy> StructuralEq for EncodedBt2020<ComponentTy>

### impl<ComponentTy> StructuralPartialEq for EncodedBt2020<ComponentTy>

## Auto Trait Implementations

### impl<ComponentTy> RefUnwindSafe for EncodedBt2020<ComponentTy> where
ComponentTy: RefUnwindSafe,

### impl<ComponentTy> Send for EncodedBt2020<ComponentTy> where
ComponentTy: Send,

### impl<ComponentTy> Sync for EncodedBt2020<ComponentTy> where
ComponentTy: Sync,

### impl<ComponentTy> Unpin for EncodedBt2020<ComponentTy> where
ComponentTy: Unpin,

### impl<ComponentTy> UnwindSafe for EncodedBt2020<ComponentTy> where
ComponentTy: UnwindSafe,

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### pub fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

### impl<T> CallHasher for T where
T: Hash + ?Sized,

#### pub fn get_hash<H, B>(value: &H, build_hasher: &B) -> u64 where
H: Hash + ?Sized,
B: BuildHasher,

### impl<T> Downcast for T where
T: Any,

#### pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

Convert `Box<dyn Trait>` (where `Trait: Downcast`) to `Box<dyn Any>`. `Box<dyn Any>` can then be further `downcast` into `Box<ConcreteType>` where `ConcreteType` implements `Trait`. Read more

#### pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

Convert `Rc<Trait>` (where `Trait: Downcast`) to `Rc<Any>`. `Rc<Any>` can then be further `downcast` into `Rc<ConcreteType>` where `ConcreteType` implements `Trait`. Read more

#### pub fn as_any(&self) -> &(dyn Any + 'static)

Convert `&Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&Any`’s vtable from `&Trait`’s. Read more

#### pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert `&mut Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&mut Any`’s vtable from `&mut Trait`’s. Read more

### impl<T> Downcast<T> for T

#### pub fn downcast(&self) -> &T

### impl<T> DowncastSync for T where
T: Any + Send + Sync,

#### pub fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync + 'static>

Convert `Arc<Trait>` (where `Trait: Downcast`) to `Arc<Any>`. `Arc<Any>` can then be further `downcast` into `Arc<ConcreteType>` where `ConcreteType` implements `Trait`. Read more

source

### impl<T> DynEq for T where
T: Any + Eq,

source

#### fn as_any(&self) -> &dyn Any

source

#### fn dyn_eq(&self, other: &dyn DynEq) -> bool

source

### impl<T> DynHash for T where
T: DynEq + Hash,

source

#### fn as_dyn_eq(&self) -> &dyn DynEq

source

#### fn dyn_hash(&self, state: &mut dyn Hasher)

source

### impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,

source

#### pub fn equivalent(&self, key: &K) -> bool

Compare self to `key` and return `true` if they are equal.

source

### impl<T> From<T> for T

const: unstable · source

#### pub fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T> Instrument for T

source

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more

source

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### pub fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T> Same<T> for T

#### type Output = T

Should always be `Self`

source

### impl<T> ToOwned for T where
T: Clone,

#### type Owned = T

The resulting type after obtaining ownership.

source

#### pub fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

#### pub fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

#### pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

### impl<T> Upcast<T> for T

#### pub fn upcast(&self) -> Option<&T>

source

### impl<T> WithSubscriber for T

source

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more

source

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more