Enum style::values::generics::calc::GenericCalcNode

#[repr(u8)]
pub enum GenericCalcNode<L> {
    Leaf(L),
    Negate(Box<GenericCalcNode<L>>),
    Invert(Box<GenericCalcNode<L>>),
    Sum(OwnedSlice<GenericCalcNode<L>>),
    Product(OwnedSlice<GenericCalcNode<L>>),
    MinMax(OwnedSlice<GenericCalcNode<L>>, MinMaxOp),
    Clamp {
        min: Box<GenericCalcNode<L>>,
        center: Box<GenericCalcNode<L>>,
        max: Box<GenericCalcNode<L>>,
    },
    Round {
        strategy: RoundingStrategy,
        value: Box<GenericCalcNode<L>>,
        step: Box<GenericCalcNode<L>>,
    },
    ModRem {
        dividend: Box<GenericCalcNode<L>>,
        divisor: Box<GenericCalcNode<L>>,
        op: ModRemOp,
    },
    Hypot(OwnedSlice<GenericCalcNode<L>>),
    Abs(Box<GenericCalcNode<L>>),
    Sign(Box<GenericCalcNode<L>>),
    Anchor(Box<GenericAnchorFunction<Box<GenericCalcNode<L>>, Box<GenericCalcNode<L>>>>),
    AnchorSize(Box<GenericAnchorSizeFunction<Box<GenericCalcNode<L>>>>),
}

A generic node in a calc expression.

FIXME: This would be much more elegant if we used Self in the types below, but we can’t because of https://github.com/serde-rs/serde/issues/1565.

FIXME: The following annotations are to workaround an LLVM inlining bug, see bug 1631929.

cbindgen:destructor-attributes=MOZ_NEVER_INLINE cbindgen:copy-constructor-attributes=MOZ_NEVER_INLINE cbindgen:eq-attributes=MOZ_NEVER_INLINE

Variants

Leaf(L)

A leaf node.

Negate(Box<GenericCalcNode<L>>)

A node that negates its child, e.g. Negate(1) == -1.

Invert(Box<GenericCalcNode<L>>)

A node that inverts its child, e.g. Invert(10) == 1 / 10 == 0.1. The child must always resolve to a number unit.

Sum(OwnedSlice<GenericCalcNode<L>>)

A sum node, representing a + b + c where a, b, and c are the arguments.

Product(OwnedSlice<GenericCalcNode<L>>)

A product node, representing a * b * c where a, b, and c are the arguments.

MinMax(OwnedSlice<GenericCalcNode<L>>, MinMaxOp)

A min or max function.

Clamp

A clamp() function.

Fields

min: Box<GenericCalcNode<L>>

The minimum value.

center: Box<GenericCalcNode<L>>

The central value.

max: Box<GenericCalcNode<L>>

The maximum value.

Round

A round() function.

Fields

strategy: RoundingStrategy

The rounding strategy.

value: Box<GenericCalcNode<L>>

The value to round.

step: Box<GenericCalcNode<L>>

The step value.

ModRem

A mod() or rem() function.

Fields

dividend: Box<GenericCalcNode<L>>

The dividend calculation.

divisor: Box<GenericCalcNode<L>>

The divisor calculation.

op: ModRemOp

Is the function mod or rem?

Hypot(OwnedSlice<GenericCalcNode<L>>)

A hypot() function

Abs(Box<GenericCalcNode<L>>)

An abs() function.

Sign(Box<GenericCalcNode<L>>)

A sign() function.

Anchor(Box<GenericAnchorFunction<Box<GenericCalcNode<L>>, Box<GenericCalcNode<L>>>>)

An anchor() function.

AnchorSize(Box<GenericAnchorSizeFunction<Box<GenericCalcNode<L>>>>)

An anchor-size() function.

Implementations

impl<L: CalcNodeLeaf> CalcNode<L>

fn dummy() -> Self

Create a dummy CalcNode that can be used to do replacements of other nodes.

fn coerce_to_value(&mut self, value: f32) -> Result<(), ()>

Change all the leaf nodes to have the given value. This is useful when you have calc(1px * nan) and you want to replace the product node with calc(nan), in which case the unit will be retained.

pub fn is_product_distributive(&self) -> bool

Return true if a product is distributive over this node. Is distributive: (2 + 3) * 4 = 8 + 12 Not distributive: sign(2 + 3) * 4 != sign(8 + 12)

pub fn unit(&self) -> Result<CalcUnits, ()>

If the node has a valid unit outcome, then return it, otherwise fail.

pub fn negate(&mut self)

Negate the node inline. If the node is distributive, it is replaced by the result, otherwise the node is wrapped in a [Negate] node.

fn sort_key(&self) -> SortKey

pub fn as_leaf(&self) -> Option<&L>

Returns the leaf if we can (if simplification has allowed it).

pub fn try_sum_in_place(&mut self, other: &Self) -> Result<(), ()>

Tries to merge one node into another using the sum, that is, perform x + y.

pub fn try_product_in_place(&mut self, other: &mut Self) -> bool

Tries to merge one node into another using the product, that is, perform x * y.

fn try_op<O>(&self, other: &Self, op: O) -> Result<Self, ()>

where O: Fn(f32, f32) -> f32,

Tries to apply a generic arithmetic operator

pub fn map(&mut self, op: impl FnMut(f32) -> f32) -> Result<(), ()>

Map the value of this node with the given operation.

pub fn map_leaves<O, F>(&self, map: F) -> CalcNode<O>

where O: CalcNodeLeaf, F: FnMut(&L) -> O,

Convert this CalcNode into a CalcNode with a different leaf kind.

fn map_leaves_internal<O, F>(&self, map: &mut F) -> CalcNode<O>

where O: CalcNodeLeaf, F: FnMut(&L) -> O,

pub fn resolve(&self) -> Result<L, ()>

Resolve this node into a value.

pub fn resolve_map<F, NF>( &self, leaf_to_output_fn: F, node_mapping_fn: NF, ) -> Result<L, ()>

where F: FnMut(&L) -> Result<L, ()>, NF: FnMut(&CalcNode<L>) -> Result<CalcNode<L>, ()>,

Resolve this node into a value, given a function that maps the leaf values.

fn resolve_internal<F, NF>( &self, leaf_to_output_fn: &mut F, node_mapping_fn: &mut NF, ) -> Result<L, ()>

where F: FnMut(&L) -> Result<L, ()>, NF: FnMut(&CalcNode<L>) -> Result<CalcNode<L>, ()>,

fn is_negative_leaf(&self) -> Result<bool, ()>

fn is_zero_leaf(&self) -> Result<bool, ()>

fn is_infinite_leaf(&self) -> Result<bool, ()>

fn is_nan_leaf(&self) -> Result<bool, ()>

pub fn visit_depth_first(&mut self, f: impl FnMut(&mut Self))

Visits all the nodes in this calculation tree recursively, starting by the leaves and bubbling all the way up.

This is useful for simplification, but can also be used for validation and such.

fn visit_depth_first_internal(&mut self, f: &mut impl FnMut(&mut Self))

pub fn simplify_and_sort_direct_children(&mut self)

This function simplifies and sorts the calculation of the specified node. It simplifies directly nested nodes while assuming that all nodes below it have already been simplified. It is recommended to use this function in combination with visit_depth_first().

This function is necessary only if the node needs to be preserved after parsing, specifically for <length-percentage> cases where the calculation contains percentages or relative units. Otherwise, the node can be evaluated using resolve(), which will automatically provide a simplified value.

https://drafts.csswg.org/css-values-4/#calc-simplification

pub fn simplify_and_sort(&mut self)

Simplifies and sorts the kids in the whole calculation subtree.

fn to_css_impl<W>( &self, dest: &mut CssWriter<'_, W>, level: ArgumentLevel, ) -> Result

where W: Write,

fn compare( &self, other: &Self, basis_positive: PositivePercentageBasis, ) -> Option<Ordering>

fn gt(&self, other: &Self, basis_positive: PositivePercentageBasis) -> bool

Return whether a leaf is greater than another.

fn lt(&self, other: &Self, basis_positive: PositivePercentageBasis) -> bool

Return whether a leaf is less than another.

fn lte(&self, other: &Self, basis_positive: PositivePercentageBasis) -> bool

Return whether a leaf is smaller or equal than another.

impl GenericCalcNode<Leaf>

fn parse_one<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, allowed: AllowParse, ) -> Result<Self, ParseError<'i>>

Tries to parse a single element in the expression, that is, a <length>, <angle>, <time>, <percentage>, <resolution>, etc.

May return a “complex” CalcNode, in the presence of a parenthesized expression, for example.

pub fn parse<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, function: MathFunction, allowed: AllowParse, ) -> Result<Self, ParseError<'i>>

Parse a top-level calc expression, with all nested sub-expressions.

This is in charge of parsing, for example, 2 + 3 * 100%.

fn parse_angle_argument<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, ) -> Result<CSSFloat, ParseError<'i>>

fn parse_number_argument<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, ) -> Result<CSSFloat, ParseError<'i>>

fn parse_argument<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, allowed: AllowParse, ) -> Result<Self, ParseError<'i>>

fn parse_product<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, allowed: AllowParse, ) -> Result<Self, ParseError<'i>>

Parse a top-level calc expression, and all the products that may follow, and stop as soon as a non-product expression is found.

This should parse correctly:

• 2
• 2 * 2
• 2 * 2 + 2 (but will leave the + 2 unparsed).

fn try_resolve<'i, 't, F>( input: &Parser<'i, 't>, closure: F, ) -> Result<CSSFloat, ParseError<'i>>

where F: FnOnce() -> Result<CSSFloat, ()>,

pub fn into_length_or_percentage( self, clamping_mode: AllowedNumericType, ) -> Result<CalcLengthPercentage, ()>

Tries to simplify this expression into a <length> or <percentage> value.

fn to_time(&self, clamping_mode: Option<AllowedNumericType>) -> Result<Time, ()>

Tries to simplify this expression into a <time> value.

fn to_resolution(&self) -> Result<Resolution, ()>

Tries to simplify the expression into a <resolution> value.

fn to_angle(&self) -> Result<Angle, ()>

Tries to simplify this expression into an Angle value.

fn to_number(&self) -> Result<CSSFloat, ()>

Tries to simplify this expression into a <number> value.

fn to_percentage(&self) -> Result<CSSFloat, ()>

Tries to simplify this expression into a <percentage> value.

pub fn math_function<'i>( _: &ParserContext<'_>, name: &CowRcStr<'i>, location: SourceLocation, ) -> Result<MathFunction, ParseError<'i>>

Given a function name, and the location from where the token came from, return a mathematical function corresponding to that name or an error.

pub fn parse_integer<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, function: MathFunction, ) -> Result<CSSInteger, ParseError<'i>>

Convenience parsing function for integers.

pub fn parse_length_or_percentage<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, clamping_mode: AllowedNumericType, function: MathFunction, allow_anchor: AllowAnchorPositioningFunctions, ) -> Result<CalcLengthPercentage, ParseError<'i>>

Convenience parsing function for <length> | <percentage>, and, optionally, anchor().

pub fn parse_percentage<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, function: MathFunction, ) -> Result<CSSFloat, ParseError<'i>>

Convenience parsing function for percentages.

pub fn parse_length<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, clamping_mode: AllowedNumericType, function: MathFunction, ) -> Result<CalcLengthPercentage, ParseError<'i>>

Convenience parsing function for <length>.

pub fn parse_number<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, function: MathFunction, ) -> Result<CSSFloat, ParseError<'i>>

Convenience parsing function for <number>.

pub fn parse_angle<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, function: MathFunction, ) -> Result<Angle, ParseError<'i>>

Convenience parsing function for <angle>.

pub fn parse_time<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, clamping_mode: AllowedNumericType, function: MathFunction, ) -> Result<Time, ParseError<'i>>

Convenience parsing function for <time>.

pub fn parse_resolution<'i, 't>( context: &ParserContext<'_>, input: &mut Parser<'i, 't>, function: MathFunction, ) -> Result<Resolution, ParseError<'i>>

Convenience parsing function for <resolution>.

Trait Implementations

impl<L: Clone> Clone for GenericCalcNode<L>

fn clone(&self) -> GenericCalcNode<L>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Debug> Debug for GenericCalcNode<L>

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

Formats the value using the given formatter.

impl<'de, L> Deserialize<'de> for GenericCalcNode<L>

where L: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<L> MallocSizeOf for GenericCalcNode<L>

where L: MallocSizeOf,

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl<L: PartialEq> PartialEq for GenericCalcNode<L>

fn eq(&self, other: &GenericCalcNode<L>) -> 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<L> Serialize for GenericCalcNode<L>

where L: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<L> ToAnimatedZero for GenericCalcNode<L>

where L: ToAnimatedZero,

fn to_animated_zero(&self) -> Result<Self, ()>

Returns a value that, when added with an underlying value, will produce the underlying value. This is used for SMIL animation’s “by-animation” where SMIL first interpolates from the zero value to the ‘by’ value, and then adds the result to the underlying value.

impl<L: CalcNodeLeaf> ToCss for CalcNode<L>

fn to_css<W>(&self, dest: &mut CssWriter<'_, W>) -> Result

where W: Write,

https://drafts.csswg.org/css-values/#calc-serialize

fn to_css_string(&self) -> String

Serialize self in CSS syntax and return a string.

impl<L> ToResolvedValue for GenericCalcNode<L>

where L: ToResolvedValue,

type ResolvedValue = GenericCalcNode<<L as ToResolvedValue>::ResolvedValue>

The resolved value type we’re going to be converted to.

fn from_resolved_value(from: Self::ResolvedValue) -> Self

Convert a resolved value to resolved value form.

fn to_resolved_value(self, context: &Context<'_>) -> Self::ResolvedValue

Convert a resolved value to a resolved value.

impl<L> ToShmem for GenericCalcNode<L>

where L: ToShmem,

fn to_shmem(&self, builder: &mut SharedMemoryBuilder) -> Result<Self>

Clones this value into a form suitable for writing into a SharedMemoryBuilder.

impl<L> StructuralPartialEq for GenericCalcNode<L>