Trait MaybeDither

pub trait MaybeDither<T: Sample>: Sample {
    const DITHERABLE: bool;

    // Required method
    fn maybe_dither<D: Dither<Self, T>>(self, dither: &mut D) -> Self;
}

MaybeDither conditionally applies a dither to a sample depending on the source and destination sample types.

Required Associated Constants

const DITHERABLE: bool

Required Methods

fn maybe_dither<D: Dither<Self, T>>(self, dither: &mut D) -> Self

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl MaybeDither<f32> for f32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f32, f32>>(self, _: &mut D) -> Self

impl MaybeDither<f32> for f64

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f64, f32>>(self, _: &mut D) -> Self

impl MaybeDither<f32> for i8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i8, f32>>(self, _: &mut D) -> Self

impl MaybeDither<f32> for i16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i16, f32>>(self, _: &mut D) -> Self

impl MaybeDither<f32> for i32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i32, f32>>(self, _: &mut D) -> Self

impl MaybeDither<f32> for u8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u8, f32>>(self, _: &mut D) -> Self

impl MaybeDither<f32> for u16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u16, f32>>(self, _: &mut D) -> Self

impl MaybeDither<f32> for u32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u32, f32>>(self, _: &mut D) -> Self

impl MaybeDither<f64> for f32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f32, f64>>(self, _: &mut D) -> Self

impl MaybeDither<f64> for f64

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f64, f64>>(self, _: &mut D) -> Self

impl MaybeDither<f64> for i8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i8, f64>>(self, _: &mut D) -> Self

impl MaybeDither<f64> for i16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i16, f64>>(self, _: &mut D) -> Self

impl MaybeDither<f64> for i32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i32, f64>>(self, _: &mut D) -> Self

impl MaybeDither<f64> for u8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u8, f64>>(self, _: &mut D) -> Self

impl MaybeDither<f64> for u16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u16, f64>>(self, _: &mut D) -> Self

impl MaybeDither<f64> for u32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u32, f64>>(self, _: &mut D) -> Self

impl MaybeDither<i8> for f32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f32, i8>>(self, _: &mut D) -> Self

impl MaybeDither<i8> for f64

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f64, i8>>(self, _: &mut D) -> Self

impl MaybeDither<i8> for i8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i8, i8>>(self, _: &mut D) -> Self

impl MaybeDither<i8> for i16

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<i16, i8>>(self, dither: &mut D) -> Self

impl MaybeDither<i8> for i32

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<i32, i8>>(self, dither: &mut D) -> Self

impl MaybeDither<i8> for u8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u8, i8>>(self, _: &mut D) -> Self

impl MaybeDither<i8> for u16

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<u16, i8>>(self, dither: &mut D) -> Self

impl MaybeDither<i8> for u32

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<u32, i8>>(self, dither: &mut D) -> Self

impl MaybeDither<i16> for f32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f32, i16>>(self, _: &mut D) -> Self

impl MaybeDither<i16> for f64

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f64, i16>>(self, _: &mut D) -> Self

impl MaybeDither<i16> for i8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i8, i16>>(self, _: &mut D) -> Self

impl MaybeDither<i16> for i16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i16, i16>>(self, _: &mut D) -> Self

impl MaybeDither<i16> for i32

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<i32, i16>>(self, dither: &mut D) -> Self

impl MaybeDither<i16> for u8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u8, i16>>(self, _: &mut D) -> Self

impl MaybeDither<i16> for u16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u16, i16>>(self, _: &mut D) -> Self

impl MaybeDither<i16> for u32

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<u32, i16>>(self, dither: &mut D) -> Self

impl MaybeDither<i32> for f32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f32, i32>>(self, _: &mut D) -> Self

impl MaybeDither<i32> for f64

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f64, i32>>(self, _: &mut D) -> Self

impl MaybeDither<i32> for i8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i8, i32>>(self, _: &mut D) -> Self

impl MaybeDither<i32> for i16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i16, i32>>(self, _: &mut D) -> Self

impl MaybeDither<i32> for i32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i32, i32>>(self, _: &mut D) -> Self

impl MaybeDither<i32> for u8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u8, i32>>(self, _: &mut D) -> Self

impl MaybeDither<i32> for u16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u16, i32>>(self, _: &mut D) -> Self

impl MaybeDither<i32> for u32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u32, i32>>(self, _: &mut D) -> Self

impl MaybeDither<u8> for f32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f32, u8>>(self, _: &mut D) -> Self

impl MaybeDither<u8> for f64

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f64, u8>>(self, _: &mut D) -> Self

impl MaybeDither<u8> for i8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i8, u8>>(self, _: &mut D) -> Self

impl MaybeDither<u8> for i16

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<i16, u8>>(self, dither: &mut D) -> Self

impl MaybeDither<u8> for i32

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<i32, u8>>(self, dither: &mut D) -> Self

impl MaybeDither<u8> for u8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u8, u8>>(self, _: &mut D) -> Self

impl MaybeDither<u8> for u16

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<u16, u8>>(self, dither: &mut D) -> Self

impl MaybeDither<u8> for u32

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<u32, u8>>(self, dither: &mut D) -> Self

impl MaybeDither<u16> for f32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f32, u16>>(self, _: &mut D) -> Self

impl MaybeDither<u16> for f64

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f64, u16>>(self, _: &mut D) -> Self

impl MaybeDither<u16> for i8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i8, u16>>(self, _: &mut D) -> Self

impl MaybeDither<u16> for i16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i16, u16>>(self, _: &mut D) -> Self

impl MaybeDither<u16> for i32

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<i32, u16>>(self, dither: &mut D) -> Self

impl MaybeDither<u16> for u8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u8, u16>>(self, _: &mut D) -> Self

impl MaybeDither<u16> for u16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u16, u16>>(self, _: &mut D) -> Self

impl MaybeDither<u16> for u32

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<u32, u16>>(self, dither: &mut D) -> Self

impl MaybeDither<u32> for f32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f32, u32>>(self, _: &mut D) -> Self

impl MaybeDither<u32> for f64

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f64, u32>>(self, _: &mut D) -> Self

impl MaybeDither<u32> for i8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i8, u32>>(self, _: &mut D) -> Self

impl MaybeDither<u32> for i16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i16, u32>>(self, _: &mut D) -> Self

impl MaybeDither<u32> for i32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i32, u32>>(self, _: &mut D) -> Self

impl MaybeDither<u32> for u8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u8, u32>>(self, _: &mut D) -> Self

impl MaybeDither<u32> for u16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u16, u32>>(self, _: &mut D) -> Self

impl MaybeDither<u32> for u32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u32, u32>>(self, _: &mut D) -> Self

impl MaybeDither<i24> for f32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f32, i24>>(self, _: &mut D) -> Self

impl MaybeDither<i24> for f64

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f64, i24>>(self, _: &mut D) -> Self

impl MaybeDither<i24> for i8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i8, i24>>(self, _: &mut D) -> Self

impl MaybeDither<i24> for i16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i16, i24>>(self, _: &mut D) -> Self

impl MaybeDither<i24> for i32

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<i32, i24>>(self, dither: &mut D) -> Self

impl MaybeDither<i24> for u8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u8, i24>>(self, _: &mut D) -> Self

impl MaybeDither<i24> for u16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u16, i24>>(self, _: &mut D) -> Self

impl MaybeDither<i24> for u32

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<u32, i24>>(self, dither: &mut D) -> Self

impl MaybeDither<u24> for f32

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f32, u24>>(self, _: &mut D) -> Self

impl MaybeDither<u24> for f64

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<f64, u24>>(self, _: &mut D) -> Self

impl MaybeDither<u24> for i8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i8, u24>>(self, _: &mut D) -> Self

impl MaybeDither<u24> for i16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<i16, u24>>(self, _: &mut D) -> Self

impl MaybeDither<u24> for i32

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<i32, u24>>(self, dither: &mut D) -> Self

impl MaybeDither<u24> for u8

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u8, u24>>(self, _: &mut D) -> Self

impl MaybeDither<u24> for u16

const DITHERABLE: bool = false

fn maybe_dither<D: Dither<u16, u24>>(self, _: &mut D) -> Self

impl MaybeDither<u24> for u32

const DITHERABLE: bool = true

fn maybe_dither<D: Dither<u32, u24>>(self, dither: &mut D) -> Self

Implementors

impl MaybeDither<f32> for i24

const DITHERABLE: bool = false

impl MaybeDither<f32> for u24

const DITHERABLE: bool = false

impl MaybeDither<f64> for i24

const DITHERABLE: bool = false

impl MaybeDither<f64> for u24

const DITHERABLE: bool = false

impl MaybeDither<i8> for i24

const DITHERABLE: bool = true

impl MaybeDither<i8> for u24

const DITHERABLE: bool = true

impl MaybeDither<i16> for i24

const DITHERABLE: bool = true

impl MaybeDither<i16> for u24

const DITHERABLE: bool = true

impl MaybeDither<i32> for i24

const DITHERABLE: bool = false

impl MaybeDither<i32> for u24

const DITHERABLE: bool = false

impl MaybeDither<u8> for i24

const DITHERABLE: bool = true

impl MaybeDither<u8> for u24

const DITHERABLE: bool = true

impl MaybeDither<u16> for i24

const DITHERABLE: bool = true

impl MaybeDither<u16> for u24

const DITHERABLE: bool = true

impl MaybeDither<u32> for i24

const DITHERABLE: bool = false

impl MaybeDither<u32> for u24

const DITHERABLE: bool = false

impl MaybeDither<i24> for i24

const DITHERABLE: bool = false

impl MaybeDither<i24> for u24

const DITHERABLE: bool = false

impl MaybeDither<u24> for i24

const DITHERABLE: bool = false

impl MaybeDither<u24> for u24

const DITHERABLE: bool = false