Struct Tag

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

An OpenType tag.

Per the spec, a tag is a 4-byte array where each byte is in the printable ASCII range (0x20..=0x7E).

We do not strictly enforce this constraint as it is possible to encounter invalid tags in existing fonts, and these need to be representable.

When creating new tags we encourage ensuring that the tag is valid, either by using Tag::new_checked or by calling Tag::validate on an existing tag.

Implementations

impl Tag

pub const fn new(src: &[u8; 4]) -> Tag

Construct a Tag from raw bytes.

This does not perform any validation; use Tag::new_checked for a constructor that validates input.

pub const fn new_checked(src: &[u8]) -> Result<Tag, InvalidTag>

Attempt to create a Tag from raw bytes.

The slice must contain between 1 and 4 bytes, each in the printable ascii range (0x20..=0x7E).

If the input has fewer than four bytes, it will be padded with spaces.

This method returns an InvalidTag error if the tag does conform to the spec.

pub const fn from_u32(src: u32) -> Tag

Construct a new Tag from a big-endian u32, without performing validation.

This is provided as a convenience method for interop with code that stores tags as big-endian u32s.

pub const fn from_be_bytes(bytes: [u8; 4]) -> Tag

Create a tag from raw big-endian bytes.

Prefer to use Tag::new (in const contexts) or Tag::new_checked when creating a Tag.

This does not check the input, and is only intended to be used during parsing, where invalid inputs are accepted.

pub const fn to_be_bytes(self) -> [u8; 4]

Return the memory representation of this tag.

pub fn into_bytes(self) -> [u8; 4]

Return the raw byte array representing this tag.

pub fn validate(self) -> Result<(), InvalidTag>

Check that the tag conforms with the spec.

This is intended for use during things like santization or lint passes on existing fonts; if you are creating a new tag, you should prefer Tag::new_checked.

Specifically, this checks the following conditions

• the tag is not empty
• the tag contains only characters in the printable ascii range (0x20..=0x1F)
• the tag does not begin with a space
• the tag does not contain any non-space characters after the first space

Trait Implementations

impl AsRef<[u8]> for Tag

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<[u8; 4]> for Tag

fn borrow(&self) -> &[u8; 4]

Immutably borrows from an owned value.

impl Clone for Tag

fn clone(&self) -> Tag

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Tag

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

Formats the value using the given formatter.

impl Default for Tag

fn default() -> Tag

Returns the “default value” for a type.

impl Display for Tag

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

Formats the value using the given formatter.

impl Domain for Tag

fn to_u32(&self) -> u32

Converts this value of T to a value in u32.

fn from_u32(member: InDomain) -> Tag

Converts a mapped u32 value back to T.

fn is_continuous() -> bool

Returns true if all u32 values between the mapped u32 min and mapped u32 max value of T are used.

fn ordered_values() -> impl DoubleEndedIterator

Returns an iterator which iterates over all values in the domain of T

fn ordered_values_range(range: RangeInclusive<Tag>) -> impl DoubleEndedIterator

Return an iterator which iterates over all values of T in the given range.

fn count() -> u64

Returns the number of members in the domain.

impl FromStr for Tag

type Err = InvalidTag

The associated error which can be returned from parsing.

fn from_str(src: &str) -> Result<Tag, <Tag as FromStr>::Err>

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

impl Hash for Tag

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 Tag

fn cmp(&self, other: &Tag) -> 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<&[u8]> for Tag

fn eq(&self, other: &&[u8]) -> 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<&str> for Tag

fn eq(&self, other: &&str) -> 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<[u8; 4]> for Tag

fn eq(&self, other: &[u8; 4]) -> 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<str> for Tag

fn eq(&self, other: &str) -> 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 Tag

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

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

type Raw = [u8; 4]

The raw byte representation of this type.

fn to_raw(self) -> <Tag as Scalar>::Raw

Encode this type as raw big-endian bytes

fn from_raw(raw: <Tag as Scalar>::Raw) -> Tag

Create an instance of this type from raw big-endian bytes

fn read(slice: &[u8]) -> Option<Self>

Attempt to read a scalar from a slice.

impl Zeroable for Tag

fn zeroed() -> Self

Calls zeroed.

impl AnyBitPattern for Tag

impl Copy for Tag

impl Eq for Tag

impl StructuralPartialEq for Tag