Enum DimensionUnit

pub enum DimensionUnit {
    Unknown = 0,
    Cap = 1,
    Ch = 2,
    Cm = 3,
    Cqb = 4,
    Cqh = 5,
    Cqi = 6,
    Cqmax = 7,
    Cqmin = 8,
    Cqw = 9,
    Db = 10,
    Deg = 11,
    Dpcm = 12,
    Dpi = 13,
    Dppx = 14,
    Dvb = 15,
    Dvh = 16,
    Dvi = 17,
    Dvmax = 18,
    Dvmin = 19,
    Dvw = 20,
    Em = 21,
    Ex = 22,
    Fr = 23,
    Grad = 24,
    Hz = 25,
    Ic = 26,
    In = 27,
    Khz = 28,
    Lh = 29,
    Lvb = 30,
    Lvh = 31,
    Lvi = 32,
    Lvmax = 33,
    Lvmin = 34,
    Lvw = 35,
    Mm = 36,
    Ms = 37,
    Pc = 38,
    Percent = 39,
    Pt = 40,
    Px = 41,
    Q = 42,
    Rad = 43,
    Rcap = 44,
    Rch = 45,
    Rem = 46,
    Rex = 47,
    Ric = 48,
    Rlh = 49,
    S = 50,
    Svb = 51,
    Svh = 52,
    Svi = 53,
    Svmax = 54,
    Svmin = 55,
    Svw = 56,
    Turn = 57,
    Vb = 58,
    Vh = 59,
    Vi = 60,
    Vmax = 61,
    Vmin = 62,
    Vw = 63,
    X = 64,
}

Represents a Kind::Dimension’s unit, if it is “known”: defined by the CSS grammar.

In order to more efficiently lex CSS, the known dimension units are encoded into Tokens. This avoids the need for subsequent downstream passes to consult the underlying string data to establish what kind of dimension unit the Kind::Dimension represents.

This enum captures all known and defined units per the CSS specifications. Custom units (e.g. those beginning with a double dash (--)), unknown units, or units using escape characters will all be represented using the DimensionUnit::Unknown variant which means the underlying &str must be consulted.

Example

use css_lexer::*;
let mut lexer = Lexer::new("10px");
{
    let token = lexer.advance();
    assert_eq!(token, Kind::Dimension);
    assert_eq!(token, DimensionUnit::Px);
    let unit = token.dimension_unit();
    let str: &'static str = unit.into();
    assert_eq!(str, "px");
}

Variants

Unknown = 0

Cap = 1

Ch = 2

Cm = 3

Cqb = 4

Cqh = 5

Cqi = 6

Cqmax = 7

Cqmin = 8

Cqw = 9

Db = 10

Deg = 11

Dpcm = 12

Dpi = 13

Dppx = 14

Dvb = 15

Dvh = 16

Dvi = 17

Dvmax = 18

Dvmin = 19

Dvw = 20

Em = 21

Ex = 22

Fr = 23

Grad = 24

Hz = 25

Ic = 26

In = 27

Khz = 28

Lh = 29

Lvb = 30

Lvh = 31

Lvi = 32

Lvmax = 33

Lvmin = 34

Lvw = 35

Mm = 36

Ms = 37

Pc = 38

Percent = 39

Pt = 40

Px = 41

Q = 42

Rad = 43

Rcap = 44

Rch = 45

Rem = 46

Rex = 47

Ric = 48

Rlh = 49

S = 50

Svb = 51

Svh = 52

Svi = 53

Svmax = 54

Svmin = 55

Svw = 56

Turn = 57

Vb = 58

Vh = 59

Vi = 60

Vmax = 61

Vmin = 62

Vw = 63

X = 64

Implementations

impl DimensionUnit

pub fn is_empty(&self) -> bool

pub const fn len(&self) -> u32

Trait Implementations

impl Clone for DimensionUnit

fn clone(&self) -> DimensionUnit

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DimensionUnit

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

Formats the value using the given formatter.

impl Default for DimensionUnit

fn default() -> DimensionUnit

Returns the “default value” for a type.

impl From<&str> for DimensionUnit

fn from(value: &str) -> DimensionUnit

Converts to this type from the input type.

impl From<Cursor> for DimensionUnit

fn from(cursor: Cursor) -> DimensionUnit

Converts to this type from the input type.

impl From<DimensionUnit> for &'static str

fn from(value: DimensionUnit) -> &'static str

Converts to this type from the input type.

impl From<Token> for DimensionUnit

fn from(token: Token) -> DimensionUnit

Converts to this type from the input type.

impl From<u8> for DimensionUnit

fn from(value: u8) -> DimensionUnit

Converts to this type from the input type.

impl Hash for DimensionUnit

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

where __H: Hasher,

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 DimensionUnit

fn cmp(&self, other: &DimensionUnit) -> 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.

impl PartialEq<DimensionUnit> for &Cursor

fn eq(&self, other: &DimensionUnit) -> 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 PartialEq<DimensionUnit> for Cursor

fn eq(&self, other: &DimensionUnit) -> 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 PartialEq<DimensionUnit> for Token

fn eq(&self, other: &DimensionUnit) -> 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 PartialEq for DimensionUnit

fn eq(&self, other: &DimensionUnit) -> 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 PartialOrd for DimensionUnit

fn partial_cmp(&self, other: &DimensionUnit) -> 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 Serialize for DimensionUnit

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for DimensionUnit

impl Eq for DimensionUnit

impl StructuralPartialEq for DimensionUnit