# Struct png::Transformations

source · `pub struct Transformations { /* private fields */ }`

## Expand description

## §Output transformations

Only `IDENTITY`

and `TRANSFORM_EXPAND | TRANSFORM_STRIP_ALPHA`

can be used at the moment.

## Implementations§

source§### impl Transformations

### impl Transformations

source#### pub const STRIP_ALPHA: Self = _

#### pub const STRIP_ALPHA: Self = _

Discard the alpha channel

source#### pub const EXPAND: Self = _

#### pub const EXPAND: Self = _

Expand paletted images to RGB; expand grayscale images of less than 8-bit depth to 8-bit depth; and expand tRNS chunks to alpha channels.

source#### pub const INVERT_MONO: Self = _

#### pub const INVERT_MONO: Self = _

Invert monochrome images

source#### pub const SWAP_ALPHA: Self = _

#### pub const SWAP_ALPHA: Self = _

Flip RGBA to ARGB or GA to AG

source#### pub const SWAP_ENDIAN: Self = _

#### pub const SWAP_ENDIAN: Self = _

Byte-swap 16-bit samples

source#### pub const INVERT_ALPHA: Self = _

#### pub const INVERT_ALPHA: Self = _

Change alpha from opacity to transparency

#### pub const STRIP_FILLER: Self = _

#### pub const STRIP_FILLER_BEFORE: Self = _

#### pub const STRIP_FILLER_AFTER: Self = _

#### pub const GRAY_TO_RGB: Self = _

#### pub const EXPAND_16: Self = _

#### pub const SCALE_16: Self = _

source#### pub const fn from_bits(bits: u32) -> Option<Self>

#### pub const fn from_bits(bits: u32) -> Option<Self>

Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.

source#### pub const fn from_bits_truncate(bits: u32) -> Self

#### pub const fn from_bits_truncate(bits: u32) -> Self

Convert from underlying bit representation, dropping any bits that do not correspond to flags.

source#### pub const unsafe fn from_bits_unchecked(bits: u32) -> Self

#### pub const unsafe fn from_bits_unchecked(bits: u32) -> Self

Convert from underlying bit representation, preserving all bits (even those not corresponding to a defined flag).

##### §Safety

The caller of the `bitflags!`

macro can chose to allow or
disallow extra bits for their bitflags type.

The caller of `from_bits_unchecked()`

has to ensure that
all bits correspond to a defined flag or that extra bits
are valid for this bitflags type.

source#### pub const fn intersects(&self, other: Self) -> bool

#### pub const fn intersects(&self, other: Self) -> bool

Returns `true`

if there are flags common to both `self`

and `other`

.

source#### pub const fn contains(&self, other: Self) -> bool

#### pub const fn contains(&self, other: Self) -> bool

Returns `true`

if all of the flags in `other`

are contained within `self`

.

source#### pub fn set(&mut self, other: Self, value: bool)

#### pub fn set(&mut self, other: Self, value: bool)

Inserts or removes the specified flags depending on the passed value.

source#### pub const fn intersection(self, other: Self) -> Self

#### pub const fn intersection(self, other: Self) -> Self

Returns the intersection between the flags in `self`

and
`other`

.

Specifically, the returned set contains only the flags which are
present in *both* `self`

*and* `other`

.

This is equivalent to using the `&`

operator (e.g.
`ops::BitAnd`

), as in `flags & other`

.

source#### pub const fn union(self, other: Self) -> Self

#### pub const fn union(self, other: Self) -> Self

Returns the union of between the flags in `self`

and `other`

.

Specifically, the returned set contains all flags which are
present in *either* `self`

*or* `other`

, including any which are
present in both (see `Self::symmetric_difference`

if that
is undesirable).

This is equivalent to using the `|`

operator (e.g.
`ops::BitOr`

), as in `flags | other`

.

source#### pub const fn difference(self, other: Self) -> Self

#### pub const fn difference(self, other: Self) -> Self

Returns the difference between the flags in `self`

and `other`

.

Specifically, the returned set contains all flags present in
`self`

, except for the ones present in `other`

.

It is also conceptually equivalent to the “bit-clear” operation:
`flags & !other`

(and this syntax is also supported).

This is equivalent to using the `-`

operator (e.g.
`ops::Sub`

), as in `flags - other`

.

source#### pub const fn symmetric_difference(self, other: Self) -> Self

#### pub const fn symmetric_difference(self, other: Self) -> Self

Returns the symmetric difference between the flags
in `self`

and `other`

.

Specifically, the returned set contains the flags present which
are present in `self`

or `other`

, but that are not present in
both. Equivalently, it contains the flags present in *exactly
one* of the sets `self`

and `other`

.

This is equivalent to using the `^`

operator (e.g.
`ops::BitXor`

), as in `flags ^ other`

.

source#### pub const fn complement(self) -> Self

#### pub const fn complement(self) -> Self

Returns the complement of this set of flags.

Specifically, the returned set contains all the flags which are
not set in `self`

, but which are allowed for this type.

Alternatively, it can be thought of as the set difference
between `Self::all()`

and `self`

(e.g. `Self::all() - self`

)

This is equivalent to using the `!`

operator (e.g.
`ops::Not`

), as in `!flags`

.

## Trait Implementations§

source§### impl Binary for Transformations

### impl Binary for Transformations

source§### impl BitAnd for Transformations

### impl BitAnd for Transformations

source§### impl BitAndAssign for Transformations

### impl BitAndAssign for Transformations

source§#### fn bitand_assign(&mut self, other: Self)

#### fn bitand_assign(&mut self, other: Self)

Disables all flags disabled in the set.

source§### impl BitOr for Transformations

### impl BitOr for Transformations

source§#### fn bitor(self, other: Transformations) -> Self

#### fn bitor(self, other: Transformations) -> Self

Returns the union of the two sets of flags.

§#### type Output = Transformations

#### type Output = Transformations

`|`

operator.source§### impl BitOrAssign for Transformations

### impl BitOrAssign for Transformations

source§#### fn bitor_assign(&mut self, other: Self)

#### fn bitor_assign(&mut self, other: Self)

Adds the set of flags.

source§### impl BitXor for Transformations

### impl BitXor for Transformations

source§### impl BitXorAssign for Transformations

### impl BitXorAssign for Transformations

source§#### fn bitxor_assign(&mut self, other: Self)

#### fn bitxor_assign(&mut self, other: Self)

Toggles the set of flags.

source§### impl Clone for Transformations

### impl Clone for Transformations

source§#### fn clone(&self) -> Transformations

#### fn clone(&self) -> Transformations

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

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

`source`

. Read moresource§### impl Debug for Transformations

### impl Debug for Transformations

source§### impl Extend<Transformations> for Transformations

### impl Extend<Transformations> for Transformations

source§#### fn extend<T: IntoIterator<Item = Self>>(&mut self, iterator: T)

#### fn extend<T: IntoIterator<Item = Self>>(&mut self, iterator: T)

source§#### fn extend_one(&mut self, item: A)

#### fn extend_one(&mut self, item: A)

`extend_one`

)source§#### fn extend_reserve(&mut self, additional: usize)

#### fn extend_reserve(&mut self, additional: usize)

`extend_one`

)source§### impl FromIterator<Transformations> for Transformations

### impl FromIterator<Transformations> for Transformations

source§#### fn from_iter<T: IntoIterator<Item = Self>>(iterator: T) -> Self

#### fn from_iter<T: IntoIterator<Item = Self>>(iterator: T) -> Self

source§### impl Hash for Transformations

### impl Hash for Transformations

source§### impl LowerHex for Transformations

### impl LowerHex for Transformations

source§### impl Not for Transformations

### impl Not for Transformations

source§### impl Octal for Transformations

### impl Octal for Transformations

source§### impl Ord for Transformations

### impl Ord for Transformations

source§#### fn cmp(&self, other: &Transformations) -> Ordering

#### fn cmp(&self, other: &Transformations) -> Ordering

1.21.0 · source§#### fn max(self, other: Self) -> Selfwhere
Self: Sized,

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

source§### impl PartialEq for Transformations

### impl PartialEq for Transformations

source§#### fn eq(&self, other: &Transformations) -> bool

#### fn eq(&self, other: &Transformations) -> bool

`self`

and `other`

values to be equal, and is used
by `==`

.source§### impl PartialOrd for Transformations

### impl PartialOrd for Transformations

source§#### fn partial_cmp(&self, other: &Transformations) -> Option<Ordering>

#### fn partial_cmp(&self, other: &Transformations) -> Option<Ordering>

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl Sub for Transformations

### impl Sub for Transformations

source§### impl SubAssign for Transformations

### impl SubAssign for Transformations

source§#### fn sub_assign(&mut self, other: Self)

#### fn sub_assign(&mut self, other: Self)

Disables all flags enabled in the set.