Struct Rotation 

pub struct Rotation(/* private fields */);

Clockwise rotation in whole degrees, applied after auto-orientation.

Any integer is accepted and normalized into 0..360, so a negative angle turns counter-clockwise and a value past a full turn wraps: -90 and 270 are the same rotation, and so are 370 and 10.

Degrees are whole numbers on purpose. The value appears verbatim in the cache key and in the signed-URL canonical string, and a fractional angle would have to round-trip bit-identically through Rust’s and JavaScript’s float formatting for a signature to verify. Whole degrees sidestep that entirely, and no real caller asks for a fraction of one.

Examples

use truss::Rotation;
use std::str::FromStr;

let rot = Rotation::from_str("270").unwrap();
assert_eq!(rot.as_degrees(), 270);

// Negative turns counter-clockwise, and wraps to the same rotation.
assert_eq!(Rotation::from_str("-90").unwrap(), rot);
// Angles past a full turn wrap too.
assert_eq!(Rotation::from_str("630").unwrap(), rot);

// Any whole angle is allowed, not just quarter turns.
assert_eq!(Rotation::from_str("45").unwrap().as_degrees(), 45);
assert!(Rotation::from_str("45.5").is_err());

assert!(Rotation::DEG_0.is_identity());
assert_eq!(Rotation::DEG_90.quarter_turns(), Some(1));
assert_eq!(Rotation::from_degrees(45).quarter_turns(), None);

Implementations

impl Rotation

pub const DEG_0: Self

No rotation.

pub const DEG_90: Self

A quarter turn clockwise.

pub const DEG_180: Self

A half turn.

pub const DEG_270: Self

Three quarter turns clockwise.

pub const fn from_degrees(degrees: i32) -> Self

Builds a rotation from any whole number of degrees, normalizing into 0..360.

Positive turns clockwise and negative turns counter-clockwise, which is the convention --rotate has always used and the one image tools generally agree on.

pub const fn as_degrees(self) -> u16

Returns the normalized degree value used by the API, the CLI, and the cache key.

pub const fn is_identity(self) -> bool

Returns true when the rotation leaves the image untouched.

pub const fn quarter_turns(self) -> Option<u8>

Returns the number of clockwise quarter turns when the angle is a multiple of 90.

A quarter turn only permutes pixels, so the pipeline keeps that exact path instead of resampling. Anything else returns None and goes through the general rotation.

Trait Implementations

impl Clone for Rotation

fn clone(&self) -> Rotation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Rotation

impl Debug for Rotation

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

Formats the value using the given formatter.

impl Display for Rotation

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

Formats the value using the given formatter.

impl Eq for Rotation

impl FromStr for Rotation

type Err = String

The associated error which can be returned from parsing.

fn from_str(value: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Rotation

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Rotation

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl PartialEq for Rotation

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Rotation

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Rotation