pub trait ToTyped {
// Provided methods
fn to_typed(&self, _dest: &mut ThinVec<TypedValue>) -> Result<(), ()> { ... }
fn to_typed_value(&self) -> Option<TypedValue> { ... }
fn to_numeric_value(&self) -> Option<NumericValue> { ... }
fn to_typed_value_list(&self) -> Option<TypedValueList> { ... }
}Expand description
Reifies a value into its Typed OM representation.
This trait is the Typed OM analogue of ToCss. Instead of serializing
values into CSS syntax, it converts them into TypedValues that can be
exposed to the DOM as CSSStyleValue subclasses.
Most consumers should use ToTyped::to_typed_value or
ToTyped::to_typed_value_list, depending on whether they need a single
reified value or the full list of reified values.
This trait is derivable with #[derive(ToTyped)]. The derived
implementation currently supports:
-
Keyword enums: Enums whose variants are all unit variants are automatically reified as
TypedValue::Keyword, using the same serialization logic asToCss. -
Bitflags structs: Structs annotated with
#[css(bitflags(single = "...", mixed = "...", overlapping_bits))]are automatically reified asTypedValue::Keywordvalues when they can be represented as a single CSS keyword. Values that would serialize to multiple CSS keywords are treated as unsupported. -
Structs and data-carrying variants: Unless treated specially (such as bitflags structs), the derive attempts to call
.to_typed()recursively on supported fields or variant payloads, producingTypedValues when possible. -
Other cases: If no automatic mapping is defined, or recursion is explicitly disabled, the derived implementation falls back to the default method (which returns
Err(()), and thusto_typed_value()returnsNone).
Over time, the derive may be extended to handle additional CSS value categories such as numeric, color, and transform types.
Summary of derive attributes recognized by #[derive(ToTyped)]:
-
#[css(bitflags(single = "...", mixed = "...", overlapping_bits))]on a struct generates keyword reification for CSS bitflags types. Values that can be represented as a single CSS keyword are reified asTypedValue::Keyword; values that would serialize to multiple CSS keywords are treated as unsupported and returnErr(()).overlapping_bitsis supported for bitflags where one keyword subsumes other internal bits, such ascontain: size. -
#[typed(skip_derive_fields)]on the type disables recursion for structs and data-carrying enum variants. -
#[css(skip)],#[typed(skip)], or#[typed(todo)]on a variant cause that variant to be treated as unsupported (the derived implementation returnsErr(())). -
#[css(skip)]on a field causes that field to be ignored during reification. -
#[css(skip_if = "...")]/#[typed(skip_if = "...")]on a field conditionally disables reification for that field. If the provided function returnstruefor the field value, the field is ignored. -
#[css(contextual_skip_if = "...")]/#[typed(contextual_skip_if = "...")]on a field conditionally disables reification for that field. The provided function is called with all fields in the current struct or variant. If it returnstrue, the field is ignored.Typed skip annotations override CSS skip annotations when both are present.
-
#[css(keyword = "...")]on a unit variant overrides the keyword that would otherwise be derived from the Rust identifier. -
#[css(comma)]on the variant indicates that supported fields may reify to multiple separate values. When this attribute is present, multipleTypedValueitems may be produced, unless#[typed(no_multiple_values)]is also present. If multiple values are not allowed and the derived implementation would produce more than one item, it returnsErr(()). -
#[typed(no_multiple_values)]on a variant prevents it from reifying to multipleTypedValueitems, even if#[css(comma)]is present. -
#[css(iterable)]on a field indicates that the field represents a list of values. Each item in the iterable is reified individually by callingToTyped::to_typedon the element type. -
#[css(if_empty = "...")]on an iterable field specifies a keyword value that should be produced when the iterable is empty. -
#[css(represents_keyword)]on a bool field causes the field name to be reified as a keyword when the field is true.
Provided Methods§
Sourcefn to_typed(&self, _dest: &mut ThinVec<TypedValue>) -> Result<(), ()>
fn to_typed(&self, _dest: &mut ThinVec<TypedValue>) -> Result<(), ()>
Attempt to convert self into one or more TypedValue items.
Implementations append any resulting values to dest. This is the
low-level entry point used by the Typed OM reification infrastructure.
Most callers should prefer ToTyped::to_typed_value or
ToTyped::to_typed_value_list.
Returning Err(()) indicates that the value cannot be represented as
a property-agnostic Typed OM value.
Sourcefn to_typed_value(&self) -> Option<TypedValue>
fn to_typed_value(&self) -> Option<TypedValue>
Attempt to convert self into a TypedValue.
Returns the first reified value as Some(TypedValue) if the value can
be reified into a property-agnostic CSSStyleValue subclass. Returns
None if the value is unrepresentable, in which case consumers
produce a property-tied CSSStyleValue instead.
Sourcefn to_numeric_value(&self) -> Option<NumericValue>
fn to_numeric_value(&self) -> Option<NumericValue>
Attempt to convert self into a NumericValue.
Returns Some(NumericValue) if the value reifies to a single
TypedValue::Numeric item. Returns None otherwise.
Sourcefn to_typed_value_list(&self) -> Option<TypedValueList>
fn to_typed_value_list(&self) -> Option<TypedValueList>
Attempt to convert self into a TypedValueList.
Returns Some(TypedValueList) if the value can be reified into one or
more property-agnostic Typed OM values. Returns None if the value is
unrepresentable, in which case consumers produce a property-tied
CSSStyleValue instead.