diff --git a/tests/FloatOptionalTest.cpp b/tests/YGFloatOptionalTest.cpp similarity index 76% rename from tests/FloatOptionalTest.cpp rename to tests/YGFloatOptionalTest.cpp index 95a3f3da..656c81f7 100644 --- a/tests/FloatOptionalTest.cpp +++ b/tests/YGFloatOptionalTest.cpp @@ -8,19 +8,18 @@ #include #include -#include +#include #include using namespace facebook; -using namespace facebook::yoga; -constexpr auto empty = FloatOptional{}; -constexpr auto zero = FloatOptional{0.0f}; -constexpr auto one = FloatOptional{1.0f}; -constexpr auto positive = FloatOptional{1234.5f}; -constexpr auto negative = FloatOptional{-9876.5f}; +constexpr auto empty = YGFloatOptional{}; +constexpr auto zero = YGFloatOptional{0.0f}; +constexpr auto one = YGFloatOptional{1.0f}; +constexpr auto positive = YGFloatOptional{1234.5f}; +constexpr auto negative = YGFloatOptional{-9876.5f}; -TEST(FloatOptional, value) { +TEST(YGFloatOptional, value) { ASSERT_TRUE(YGFloatIsUndefined(empty.unwrap())); ASSERT_EQ(zero.unwrap(), 0.0f); ASSERT_EQ(one.unwrap(), 1.0f); @@ -34,7 +33,7 @@ TEST(FloatOptional, value) { ASSERT_FALSE(negative.isUndefined()); } -TEST(FloatOptional, equality) { +TEST(YGFloatOptional, equality) { ASSERT_TRUE(empty == empty); ASSERT_TRUE(empty == YGUndefined); ASSERT_FALSE(empty == zero); @@ -59,7 +58,7 @@ TEST(FloatOptional, equality) { ASSERT_FALSE(negative == zero); } -TEST(FloatOptional, inequality) { +TEST(YGFloatOptional, inequality) { ASSERT_FALSE(empty != empty); ASSERT_FALSE(empty != YGUndefined); ASSERT_TRUE(empty != zero); @@ -84,7 +83,7 @@ TEST(FloatOptional, inequality) { ASSERT_TRUE(negative != zero); } -TEST(FloatOptional, greater_than_with_undefined) { +TEST(YGFloatOptional, greater_than_with_undefined) { ASSERT_FALSE(empty > empty); ASSERT_FALSE(empty > zero); ASSERT_FALSE(empty > one); @@ -96,7 +95,7 @@ TEST(FloatOptional, greater_than_with_undefined) { ASSERT_FALSE(negative > empty); } -TEST(FloatOptional, greater_than) { +TEST(YGFloatOptional, greater_than) { ASSERT_TRUE(zero > negative); ASSERT_FALSE(zero > zero); ASSERT_FALSE(zero > positive); @@ -106,10 +105,10 @@ TEST(FloatOptional, greater_than) { ASSERT_TRUE(one > zero); ASSERT_FALSE(one > positive); - ASSERT_TRUE(negative > FloatOptional{-INFINITY}); + ASSERT_TRUE(negative > YGFloatOptional{-INFINITY}); } -TEST(FloatOptional, less_than_with_undefined) { +TEST(YGFloatOptional, less_than_with_undefined) { ASSERT_FALSE(empty < empty); ASSERT_FALSE(zero < empty); ASSERT_FALSE(one < empty); @@ -121,7 +120,7 @@ TEST(FloatOptional, less_than_with_undefined) { ASSERT_FALSE(empty < negative); } -TEST(FloatOptional, less_than) { +TEST(YGFloatOptional, less_than) { ASSERT_TRUE(negative < zero); ASSERT_FALSE(zero < zero); ASSERT_FALSE(positive < zero); @@ -131,10 +130,10 @@ TEST(FloatOptional, less_than) { ASSERT_TRUE(zero < one); ASSERT_FALSE(positive < one); - ASSERT_TRUE(FloatOptional{-INFINITY} < negative); + ASSERT_TRUE(YGFloatOptional{-INFINITY} < negative); } -TEST(FloatOptional, greater_than_equals_with_undefined) { +TEST(YGFloatOptional, greater_than_equals_with_undefined) { ASSERT_TRUE(empty >= empty); ASSERT_FALSE(empty >= zero); ASSERT_FALSE(empty >= one); @@ -146,7 +145,7 @@ TEST(FloatOptional, greater_than_equals_with_undefined) { ASSERT_FALSE(negative >= empty); } -TEST(FloatOptional, greater_than_equals) { +TEST(YGFloatOptional, greater_than_equals) { ASSERT_TRUE(zero >= negative); ASSERT_TRUE(zero >= zero); ASSERT_FALSE(zero >= positive); @@ -156,10 +155,10 @@ TEST(FloatOptional, greater_than_equals) { ASSERT_TRUE(one >= zero); ASSERT_FALSE(one >= positive); - ASSERT_TRUE(negative >= FloatOptional{-INFINITY}); + ASSERT_TRUE(negative >= YGFloatOptional{-INFINITY}); } -TEST(FloatOptional, less_than_equals_with_undefined) { +TEST(YGFloatOptional, less_than_equals_with_undefined) { ASSERT_TRUE(empty <= empty); ASSERT_FALSE(zero <= empty); ASSERT_FALSE(one <= empty); @@ -171,7 +170,7 @@ TEST(FloatOptional, less_than_equals_with_undefined) { ASSERT_FALSE(empty <= negative); } -TEST(FloatOptional, less_than_equals) { +TEST(YGFloatOptional, less_than_equals) { ASSERT_TRUE(negative <= zero); ASSERT_TRUE(zero <= zero); ASSERT_FALSE(positive <= zero); @@ -181,32 +180,32 @@ TEST(FloatOptional, less_than_equals) { ASSERT_TRUE(zero <= one); ASSERT_FALSE(positive <= one); - ASSERT_TRUE(FloatOptional{-INFINITY} <= negative); + ASSERT_TRUE(YGFloatOptional{-INFINITY} <= negative); } -TEST(FloatOptional, addition) { +TEST(YGFloatOptional, addition) { auto n = negative.unwrap(); auto p = positive.unwrap(); ASSERT_EQ(zero + one, one); - ASSERT_EQ(negative + positive, FloatOptional{n + p}); + ASSERT_EQ(negative + positive, YGFloatOptional{n + p}); ASSERT_EQ(empty + zero, empty); ASSERT_EQ(empty + empty, empty); ASSERT_EQ(negative + empty, empty); } -TEST(YGFloatOptiona, maxOrDefined) { +TEST(YGFloatOptionalTest, maxOrDefined) { ASSERT_EQ(yoga::maxOrDefined(empty, empty), empty); ASSERT_EQ(yoga::maxOrDefined(empty, positive), positive); ASSERT_EQ(yoga::maxOrDefined(negative, empty), negative); - ASSERT_EQ(yoga::maxOrDefined(negative, FloatOptional{-INFINITY}), negative); + ASSERT_EQ(yoga::maxOrDefined(negative, YGFloatOptional{-INFINITY}), negative); ASSERT_EQ( - yoga::maxOrDefined(FloatOptional{1.0f}, FloatOptional{1.125f}), - FloatOptional{1.125f}); + yoga::maxOrDefined(YGFloatOptional{1.0f}, YGFloatOptional{1.125f}), + YGFloatOptional{1.125f}); } -TEST(FloatOptional, unwrap) { +TEST(YGFloatOptionalTest, unwrap) { ASSERT_TRUE(YGFloatIsUndefined(empty.unwrap())); ASSERT_EQ(zero.unwrap(), 0.0f); - ASSERT_EQ(FloatOptional{123456.78f}.unwrap(), 123456.78f); + ASSERT_EQ(YGFloatOptional{123456.78f}.unwrap(), 123456.78f); } diff --git a/tests/YGStyleAccessorsTest.cpp b/tests/YGStyleAccessorsTest.cpp index 390743e3..49671bcc 100644 --- a/tests/YGStyleAccessorsTest.cpp +++ b/tests/YGStyleAccessorsTest.cpp @@ -154,24 +154,24 @@ ACCESSOR_TEST(display, YGDisplayFlex, YGDisplayNone, YGDisplayFlex) ACCESSOR_TEST( flex, - FloatOptional{}, - FloatOptional{123.45f}, - FloatOptional{-9.87f}, - FloatOptional{}) + YGFloatOptional{}, + YGFloatOptional{123.45f}, + YGFloatOptional{-9.87f}, + YGFloatOptional{}) ACCESSOR_TEST( flexGrow, - FloatOptional{}, - FloatOptional{123.45f}, - FloatOptional{-9.87f}, - FloatOptional{}) + YGFloatOptional{}, + YGFloatOptional{123.45f}, + YGFloatOptional{-9.87f}, + YGFloatOptional{}) ACCESSOR_TEST( flexShrink, - FloatOptional{}, - FloatOptional{123.45f}, - FloatOptional{-9.87f}, - FloatOptional{}) + YGFloatOptional{}, + YGFloatOptional{123.45f}, + YGFloatOptional{-9.87f}, + YGFloatOptional{}) ACCESSOR_TEST( flexBasis, @@ -243,11 +243,11 @@ INDEX_ACCESSOR_TEST( ACCESSOR_TEST( aspectRatio, - FloatOptional{}, - FloatOptional{-123.45f}, - FloatOptional{9876.5f}, - FloatOptional{0.0f}, - FloatOptional{}); + YGFloatOptional{}, + YGFloatOptional{-123.45f}, + YGFloatOptional{9876.5f}, + YGFloatOptional{0.0f}, + YGFloatOptional{}); #endif diff --git a/yoga/YGFloatOptional.h b/yoga/YGFloatOptional.h new file mode 100644 index 00000000..c4c18311 --- /dev/null +++ b/yoga/YGFloatOptional.h @@ -0,0 +1,70 @@ +/* + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#pragma once + +#include +#include +#include + +struct YGFloatOptional { +private: + float value_ = std::numeric_limits::quiet_NaN(); + +public: + explicit constexpr YGFloatOptional(float value) : value_(value) {} + constexpr YGFloatOptional() = default; + + // returns the wrapped value, or a value x with YGIsUndefined(x) == true + constexpr float unwrap() const { return value_; } + + bool isUndefined() const { return std::isnan(value_); } +}; + +// operators take YGFloatOptional by value, as it is a 32bit value + +inline bool operator==(YGFloatOptional lhs, YGFloatOptional rhs) { + return lhs.unwrap() == rhs.unwrap() || + (lhs.isUndefined() && rhs.isUndefined()); +} +inline bool operator!=(YGFloatOptional lhs, YGFloatOptional rhs) { + return !(lhs == rhs); +} + +inline bool operator==(YGFloatOptional lhs, float rhs) { + return lhs == YGFloatOptional{rhs}; +} +inline bool operator!=(YGFloatOptional lhs, float rhs) { + return !(lhs == rhs); +} + +inline bool operator==(float lhs, YGFloatOptional rhs) { + return rhs == lhs; +} +inline bool operator!=(float lhs, YGFloatOptional rhs) { + return !(lhs == rhs); +} + +inline YGFloatOptional operator+(YGFloatOptional lhs, YGFloatOptional rhs) { + return YGFloatOptional{lhs.unwrap() + rhs.unwrap()}; +} + +inline bool operator>(YGFloatOptional lhs, YGFloatOptional rhs) { + return lhs.unwrap() > rhs.unwrap(); +} + +inline bool operator<(YGFloatOptional lhs, YGFloatOptional rhs) { + return lhs.unwrap() < rhs.unwrap(); +} + +inline bool operator>=(YGFloatOptional lhs, YGFloatOptional rhs) { + return lhs > rhs || lhs == rhs; +} + +inline bool operator<=(YGFloatOptional lhs, YGFloatOptional rhs) { + return lhs < rhs || lhs == rhs; +} diff --git a/yoga/Yoga.cpp b/yoga/Yoga.cpp index dd65a264..1179e7a7 100644 --- a/yoga/Yoga.cpp +++ b/yoga/Yoga.cpp @@ -636,12 +636,12 @@ YOGA_EXPORT YGDisplay YGNodeStyleGetDisplay(const YGNodeConstRef node) { return static_cast(node)->getStyle().display(); } -// TODO(T26792433): Change the API to accept FloatOptional. +// TODO(T26792433): Change the API to accept YGFloatOptional. YOGA_EXPORT void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) { - updateStyle(node, &Style::flex, FloatOptional{flex}); + updateStyle(node, &Style::flex, YGFloatOptional{flex}); } -// TODO(T26792433): Change the API to accept FloatOptional. +// TODO(T26792433): Change the API to accept YGFloatOptional. YOGA_EXPORT float YGNodeStyleGetFlex(const YGNodeConstRef nodeRef) { auto node = static_cast(nodeRef); return node->getStyle().flex().isUndefined() @@ -649,20 +649,20 @@ YOGA_EXPORT float YGNodeStyleGetFlex(const YGNodeConstRef nodeRef) { : node->getStyle().flex().unwrap(); } -// TODO(T26792433): Change the API to accept FloatOptional. +// TODO(T26792433): Change the API to accept YGFloatOptional. YOGA_EXPORT void YGNodeStyleSetFlexGrow( const YGNodeRef node, const float flexGrow) { updateStyle( - node, &Style::flexGrow, FloatOptional{flexGrow}); + node, &Style::flexGrow, YGFloatOptional{flexGrow}); } -// TODO(T26792433): Change the API to accept FloatOptional. +// TODO(T26792433): Change the API to accept YGFloatOptional. YOGA_EXPORT void YGNodeStyleSetFlexShrink( const YGNodeRef node, const float flexShrink) { updateStyle( - node, &Style::flexShrink, FloatOptional{flexShrink}); + node, &Style::flexShrink, YGFloatOptional{flexShrink}); } YOGA_EXPORT YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) { @@ -756,7 +756,7 @@ YOGA_EXPORT YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge) { return static_cast(node)->getStyle().padding()[edge]; } -// TODO(T26792433): Change the API to accept FloatOptional. +// TODO(T26792433): Change the API to accept YGFloatOptional. YOGA_EXPORT void YGNodeStyleSetBorder( const YGNodeRef node, const YGEdge edge, @@ -771,7 +771,7 @@ YOGA_EXPORT float YGNodeStyleGetBorder( auto border = static_cast(node)->getStyle().border()[edge]; if (border.isUndefined() || border.isAuto()) { // TODO(T26792433): Rather than returning YGUndefined, change the api to - // return FloatOptional. + // return YGFloatOptional. return YGUndefined; } @@ -793,7 +793,7 @@ YOGA_EXPORT float YGNodeStyleGetGap( static_cast(node)->getStyle().gap()[gutter]; if (gapLength.isUndefined() || gapLength.isAuto()) { // TODO(T26792433): Rather than returning YGUndefined, change the api to - // return FloatOptional. + // return YGFloatOptional. return YGUndefined; } @@ -802,19 +802,19 @@ YOGA_EXPORT float YGNodeStyleGetGap( // Yoga specific properties, not compatible with flexbox specification -// TODO(T26792433): Change the API to accept FloatOptional. +// TODO(T26792433): Change the API to accept YGFloatOptional. YOGA_EXPORT float YGNodeStyleGetAspectRatio(const YGNodeConstRef node) { - const FloatOptional op = + const YGFloatOptional op = static_cast(node)->getStyle().aspectRatio(); return op.isUndefined() ? YGUndefined : op.unwrap(); } -// TODO(T26792433): Change the API to accept FloatOptional. +// TODO(T26792433): Change the API to accept YGFloatOptional. YOGA_EXPORT void YGNodeStyleSetAspectRatio( const YGNodeRef node, const float aspectRatio) { updateStyle( - node, &Style::aspectRatio, FloatOptional{aspectRatio}); + node, &Style::aspectRatio, YGFloatOptional{aspectRatio}); } YOGA_EXPORT void YGNodeStyleSetWidth(YGNodeRef node, float points) { @@ -1150,13 +1150,13 @@ static inline bool YGNodeIsLayoutDimDefined( return !YGFloatIsUndefined(value) && value >= 0.0f; } -static FloatOptional YGNodeBoundAxisWithinMinAndMax( +static YGFloatOptional YGNodeBoundAxisWithinMinAndMax( const yoga::Node* const node, const YGFlexDirection axis, - const FloatOptional value, + const YGFloatOptional value, const float axisSize) { - FloatOptional min; - FloatOptional max; + YGFloatOptional min; + YGFloatOptional max; if (isColumn(axis)) { min = yoga::resolveValue( @@ -1170,11 +1170,11 @@ static FloatOptional YGNodeBoundAxisWithinMinAndMax( node->getStyle().maxDimensions()[YGDimensionWidth], axisSize); } - if (max >= FloatOptional{0} && value > max) { + if (max >= YGFloatOptional{0} && value > max) { return max; } - if (min >= FloatOptional{0} && value < min) { + if (min >= YGFloatOptional{0} && value < min) { return min; } @@ -1190,7 +1190,8 @@ static inline float YGNodeBoundAxis( const float axisSize, const float widthSize) { return yoga::maxOrDefined( - YGNodeBoundAxisWithinMinAndMax(node, axis, FloatOptional{value}, axisSize) + YGNodeBoundAxisWithinMinAndMax( + node, axis, YGFloatOptional{value}, axisSize) .unwrap(), YGNodePaddingAndBorderForAxis(node, axis, widthSize)); } @@ -1213,10 +1214,10 @@ static void YGConstrainMaxSizeForMode( const float ownerWidth, YGMeasureMode* mode, float* size) { - const FloatOptional maxSize = + const YGFloatOptional maxSize = yoga::resolveValue( node->getStyle().maxDimensions()[dim[axis]], ownerAxisSize) + - FloatOptional(node->getMarginForAxis(axis, ownerWidth)); + YGFloatOptional(node->getMarginForAxis(axis, ownerWidth)); switch (*mode) { case YGMeasureModeExactly: case YGMeasureModeAtMost: @@ -1259,7 +1260,7 @@ static void YGNodeComputeFlexBasisForChild( YGMeasureMode childWidthMeasureMode; YGMeasureMode childHeightMeasureMode; - const FloatOptional resolvedFlexBasis = + const YGFloatOptional resolvedFlexBasis = yoga::resolveValue(child->resolveFlexBasisPtr(), mainAxisownerSize); const bool isRowStyleDimDefined = YGNodeIsStyleDimDefined(child, YGFlexDirectionRow, ownerWidth); @@ -1271,14 +1272,14 @@ static void YGNodeComputeFlexBasisForChild( (child->getConfig()->isExperimentalFeatureEnabled( YGExperimentalFeatureWebFlexBasis) && child->getLayout().computedFlexBasisGeneration != generationCount)) { - const FloatOptional paddingAndBorder = FloatOptional( + const YGFloatOptional paddingAndBorder = YGFloatOptional( YGNodePaddingAndBorderForAxis(child, mainAxis, ownerWidth)); child->setLayoutComputedFlexBasis( yoga::maxOrDefined(resolvedFlexBasis, paddingAndBorder)); } } else if (isMainAxisRow && isRowStyleDimDefined) { // The width is definite, so use that as the flex basis. - const FloatOptional paddingAndBorder = FloatOptional( + const YGFloatOptional paddingAndBorder = YGFloatOptional( YGNodePaddingAndBorderForAxis(child, YGFlexDirectionRow, ownerWidth)); child->setLayoutComputedFlexBasis(yoga::maxOrDefined( @@ -1287,8 +1288,8 @@ static void YGNodeComputeFlexBasisForChild( paddingAndBorder)); } else if (!isMainAxisRow && isColumnStyleDimDefined) { // The height is definite, so use that as the flex basis. - const FloatOptional paddingAndBorder = - FloatOptional(YGNodePaddingAndBorderForAxis( + const YGFloatOptional paddingAndBorder = + YGFloatOptional(YGNodePaddingAndBorderForAxis( child, YGFlexDirectionColumn, ownerWidth)); child->setLayoutComputedFlexBasis(yoga::maxOrDefined( yoga::resolveValue( @@ -1425,7 +1426,7 @@ static void YGNodeComputeFlexBasisForChild( depth, generationCount); - child->setLayoutComputedFlexBasis(FloatOptional(yoga::maxOrDefined( + child->setLayoutComputedFlexBasis(YGFloatOptional(yoga::maxOrDefined( child->getLayout().measuredDimensions[dim[mainAxis]], YGNodePaddingAndBorderForAxis(child, mainAxis, ownerWidth)))); } @@ -1875,13 +1876,13 @@ static float YGNodeCalculateAvailableInnerDim( if (!YGFloatIsUndefined(availableInnerDim)) { // We want to make sure our available height does not violate min and max // constraints - const FloatOptional minDimensionOptional = yoga::resolveValue( + const YGFloatOptional minDimensionOptional = yoga::resolveValue( node->getStyle().minDimensions()[dimension], ownerDim); const float minInnerDim = minDimensionOptional.isUndefined() ? 0.0f : minDimensionOptional.unwrap() - paddingAndBorder; - const FloatOptional maxDimensionOptional = yoga::resolveValue( + const YGFloatOptional maxDimensionOptional = yoga::resolveValue( node->getStyle().maxDimensions()[dimension], ownerDim); const float maxInnerDim = maxDimensionOptional.isUndefined() @@ -1957,7 +1958,7 @@ static float YGNodeComputeFlexBasisForChildren( } if (child == singleFlexChild) { child->setLayoutComputedFlexBasisGeneration(generationCount); - child->setLayoutComputedFlexBasis(FloatOptional(0)); + child->setLayoutComputedFlexBasis(YGFloatOptional(0)); } else { YGNodeComputeFlexBasisForChild( node, @@ -3521,7 +3522,7 @@ static void YGNodelayoutImpl( YGNodeBoundAxisWithinMinAndMax( node, mainAxis, - FloatOptional{maxLineMainDim}, + YGFloatOptional{maxLineMainDim}, mainAxisownerSize) .unwrap()), paddingAndBorderAxisMain), @@ -3552,7 +3553,7 @@ static void YGNodelayoutImpl( YGNodeBoundAxisWithinMinAndMax( node, crossAxis, - FloatOptional{ + YGFloatOptional{ totalLineCrossDim + paddingAndBorderAxisCross}, crossAxisownerSize) .unwrap()), diff --git a/yoga/algorithm/ResolveValue.h b/yoga/algorithm/ResolveValue.h index 2ba4bfef..033a2420 100644 --- a/yoga/algorithm/ResolveValue.h +++ b/yoga/algorithm/ResolveValue.h @@ -8,22 +8,24 @@ #pragma once #include -#include +#include namespace facebook::yoga { -inline FloatOptional resolveValue(const YGValue value, const float ownerSize) { +inline YGFloatOptional resolveValue( + const YGValue value, + const float ownerSize) { switch (value.unit) { case YGUnitPoint: - return FloatOptional{value.value}; + return YGFloatOptional{value.value}; case YGUnitPercent: - return FloatOptional{value.value * ownerSize * 0.01f}; + return YGFloatOptional{value.value * ownerSize * 0.01f}; default: - return FloatOptional{}; + return YGFloatOptional{}; } } -inline FloatOptional resolveValue(CompactValue value, float ownerSize) { +inline YGFloatOptional resolveValue(CompactValue value, float ownerSize) { return resolveValue((YGValue) value, ownerSize); } diff --git a/yoga/debug/NodeToString.cpp b/yoga/debug/NodeToString.cpp index 1b6d01d3..0a033cdb 100644 --- a/yoga/debug/NodeToString.cpp +++ b/yoga/debug/NodeToString.cpp @@ -45,7 +45,7 @@ static void appendFormattedString(std::string& str, const char* fmt, ...) { static void appendFloatOptionalIfDefined( std::string& base, const std::string key, - const FloatOptional num) { + const YGFloatOptional num) { if (!num.isUndefined()) { appendFormattedString(base, "%s: %g; ", key.c_str(), num.unwrap()); } diff --git a/yoga/node/LayoutResults.h b/yoga/node/LayoutResults.h index d920e9a2..18cc135f 100644 --- a/yoga/node/LayoutResults.h +++ b/yoga/node/LayoutResults.h @@ -8,7 +8,7 @@ #pragma once #include -#include +#include #include namespace facebook::yoga { @@ -28,7 +28,7 @@ private: public: uint32_t computedFlexBasisGeneration = 0; - FloatOptional computedFlexBasis = {}; + YGFloatOptional computedFlexBasis = {}; // Instead of recomputing the entire layout every single time, we cache some // information to break early when nothing changed diff --git a/yoga/node/Node.cpp b/yoga/node/Node.cpp index 82132f54..c30ee78e 100644 --- a/yoga/node/Node.cpp +++ b/yoga/node/Node.cpp @@ -110,7 +110,7 @@ CompactValue Node::computeColumnGap( } } -FloatOptional Node::getLeadingPosition( +YGFloatOptional Node::getLeadingPosition( const YGFlexDirection axis, const float axisSize) const { auto leadingPosition = isRow(axis) @@ -124,7 +124,7 @@ FloatOptional Node::getLeadingPosition( return yoga::resolveValue(leadingPosition, axisSize); } -FloatOptional Node::getTrailingPosition( +YGFloatOptional Node::getTrailingPosition( const YGFlexDirection axis, const float axisSize) const { auto trailingPosition = isRow(axis) @@ -162,7 +162,7 @@ bool Node::isTrailingPosDefined(const YGFlexDirection axis) const { return !trailingPosition.isUndefined(); } -FloatOptional Node::getLeadingMargin( +YGFloatOptional Node::getLeadingMargin( const YGFlexDirection axis, const float widthSize) const { auto leadingMargin = isRow(axis) @@ -170,11 +170,11 @@ FloatOptional Node::getLeadingMargin( style_.margin(), YGEdgeStart, leading[axis], CompactValue::ofZero()) : computeEdgeValueForColumn( style_.margin(), leading[axis], CompactValue::ofZero()); - return leadingMargin.isAuto() ? FloatOptional{0} + return leadingMargin.isAuto() ? YGFloatOptional{0} : yoga::resolveValue(leadingMargin, widthSize); } -FloatOptional Node::getTrailingMargin( +YGFloatOptional Node::getTrailingMargin( const YGFlexDirection axis, const float widthSize) const { auto trailingMargin = isRow(axis) @@ -183,17 +183,17 @@ FloatOptional Node::getTrailingMargin( : computeEdgeValueForColumn( style_.margin(), trailing[axis], CompactValue::ofZero()); return trailingMargin.isAuto() - ? FloatOptional{0} + ? YGFloatOptional{0} : yoga::resolveValue(trailingMargin, widthSize); } -FloatOptional Node::getMarginForAxis( +YGFloatOptional Node::getMarginForAxis( const YGFlexDirection axis, const float widthSize) const { return getLeadingMargin(axis, widthSize) + getTrailingMargin(axis, widthSize); } -FloatOptional Node::getGapForAxis( +YGFloatOptional Node::getGapForAxis( const YGFlexDirection axis, const float widthSize) const { auto gap = isRow(axis) @@ -325,7 +325,7 @@ void Node::setLayoutLastOwnerDirection(YGDirection direction) { layout_.lastOwnerDirection = direction; } -void Node::setLayoutComputedFlexBasis(const FloatOptional computedFlexBasis) { +void Node::setLayoutComputedFlexBasis(const YGFloatOptional computedFlexBasis) { layout_.computedFlexBasis = computedFlexBasis; } @@ -352,16 +352,16 @@ void Node::setLayoutDimension(float dimension, int index) { // If both left and right are defined, then use left. Otherwise return +left or // -right depending on which is defined. -FloatOptional Node::relativePosition( +YGFloatOptional Node::relativePosition( const YGFlexDirection axis, const float axisSize) const { if (isLeadingPositionDefined(axis)) { return getLeadingPosition(axis, axisSize); } - FloatOptional trailingPosition = getTrailingPosition(axis, axisSize); + YGFloatOptional trailingPosition = getTrailingPosition(axis, axisSize); if (!trailingPosition.isUndefined()) { - trailingPosition = FloatOptional{-1 * trailingPosition.unwrap()}; + trailingPosition = YGFloatOptional{-1 * trailingPosition.unwrap()}; } return trailingPosition; } @@ -383,9 +383,9 @@ void Node::setPosition( // Here we should check for `YGPositionTypeStatic` and in this case zero inset // properties (left, right, top, bottom, begin, end). // https://www.w3.org/TR/css-position-3/#valdef-position-static - const FloatOptional relativePositionMain = + const YGFloatOptional relativePositionMain = relativePosition(mainAxis, mainSize); - const FloatOptional relativePositionCross = + const YGFloatOptional relativePositionCross = relativePosition(crossAxis, crossSize); setLayoutPosition( @@ -468,7 +468,7 @@ void Node::cloneChildrenIfNeeded(void* cloneContext) { void Node::markDirtyAndPropagate() { if (!flags_.isDirty) { setDirty(true); - setLayoutComputedFlexBasis(FloatOptional()); + setLayoutComputedFlexBasis(YGFloatOptional()); if (owner_) { owner_->markDirtyAndPropagate(); } @@ -534,7 +534,7 @@ float Node::getTrailingBorder(const YGFlexDirection axis) const { return fmaxf(trailingBorder.value, 0.0f); } -FloatOptional Node::getLeadingPadding( +YGFloatOptional Node::getLeadingPadding( const YGFlexDirection axis, const float widthSize) const { auto leadingPadding = isRow(axis) @@ -546,10 +546,10 @@ FloatOptional Node::getLeadingPadding( : computeEdgeValueForColumn( style_.padding(), leading[axis], CompactValue::ofZero()); return yoga::maxOrDefined( - yoga::resolveValue(leadingPadding, widthSize), FloatOptional(0.0f)); + yoga::resolveValue(leadingPadding, widthSize), YGFloatOptional(0.0f)); } -FloatOptional Node::getTrailingPadding( +YGFloatOptional Node::getTrailingPadding( const YGFlexDirection axis, const float widthSize) const { auto trailingPadding = isRow(axis) @@ -558,21 +558,21 @@ FloatOptional Node::getTrailingPadding( : computeEdgeValueForColumn( style_.padding(), trailing[axis], CompactValue::ofZero()); return yoga::maxOrDefined( - yoga::resolveValue(trailingPadding, widthSize), FloatOptional(0.0f)); + yoga::resolveValue(trailingPadding, widthSize), YGFloatOptional(0.0f)); } -FloatOptional Node::getLeadingPaddingAndBorder( +YGFloatOptional Node::getLeadingPaddingAndBorder( const YGFlexDirection axis, const float widthSize) const { return getLeadingPadding(axis, widthSize) + - FloatOptional(getLeadingBorder(axis)); + YGFloatOptional(getLeadingBorder(axis)); } -FloatOptional Node::getTrailingPaddingAndBorder( +YGFloatOptional Node::getTrailingPaddingAndBorder( const YGFlexDirection axis, const float widthSize) const { return getTrailingPadding(axis, widthSize) + - FloatOptional(getTrailingBorder(axis)); + YGFloatOptional(getTrailingBorder(axis)); } void Node::reset() { diff --git a/yoga/node/Node.h b/yoga/node/Node.h index 542d7c08..abb1535a 100644 --- a/yoga/node/Node.h +++ b/yoga/node/Node.h @@ -66,7 +66,7 @@ private: std::array resolvedDimensions_ = { {YGValueUndefined, YGValueUndefined}}; - FloatOptional relativePosition( + YGFloatOptional relativePosition( const YGFlexDirection axis, const float axisSize) const; @@ -203,39 +203,40 @@ public: CompactValue defaultValue); // Methods related to positions, margin, padding and border - FloatOptional getLeadingPosition( + YGFloatOptional getLeadingPosition( const YGFlexDirection axis, const float axisSize) const; bool isLeadingPositionDefined(const YGFlexDirection axis) const; bool isTrailingPosDefined(const YGFlexDirection axis) const; - FloatOptional getTrailingPosition( + YGFloatOptional getTrailingPosition( const YGFlexDirection axis, const float axisSize) const; - FloatOptional getLeadingMargin( + YGFloatOptional getLeadingMargin( const YGFlexDirection axis, const float widthSize) const; - FloatOptional getTrailingMargin( + YGFloatOptional getTrailingMargin( const YGFlexDirection axis, const float widthSize) const; float getLeadingBorder(const YGFlexDirection flexDirection) const; float getTrailingBorder(const YGFlexDirection flexDirection) const; - FloatOptional getLeadingPadding( + YGFloatOptional getLeadingPadding( const YGFlexDirection axis, const float widthSize) const; - FloatOptional getTrailingPadding( + YGFloatOptional getTrailingPadding( const YGFlexDirection axis, const float widthSize) const; - FloatOptional getLeadingPaddingAndBorder( + YGFloatOptional getLeadingPaddingAndBorder( const YGFlexDirection axis, const float widthSize) const; - FloatOptional getTrailingPaddingAndBorder( + YGFloatOptional getTrailingPaddingAndBorder( const YGFlexDirection axis, const float widthSize) const; - FloatOptional getMarginForAxis( + YGFloatOptional getMarginForAxis( + const YGFlexDirection axis, + const float widthSize) const; + YGFloatOptional getGapForAxis( const YGFlexDirection axis, const float widthSize) const; - FloatOptional getGapForAxis(const YGFlexDirection axis, const float widthSize) - const; // Setters void setContext(void* context) { context_ = context; } @@ -298,7 +299,7 @@ public: void setDirty(bool isDirty); void setLayoutLastOwnerDirection(YGDirection direction); - void setLayoutComputedFlexBasis(const FloatOptional computedFlexBasis); + void setLayoutComputedFlexBasis(const YGFloatOptional computedFlexBasis); void setLayoutComputedFlexBasisGeneration( uint32_t computedFlexBasisGeneration); void setLayoutMeasuredDimension(float measuredDimension, int index); diff --git a/yoga/numeric/Comparison.h b/yoga/numeric/Comparison.h index 86ed16fa..4e9b3515 100644 --- a/yoga/numeric/Comparison.h +++ b/yoga/numeric/Comparison.h @@ -10,7 +10,7 @@ #include #include -#include +#include #include namespace facebook::yoga { @@ -30,7 +30,7 @@ inline float minOrDefined(const float a, const float b) { return std::isnan(a) ? b : a; } -inline FloatOptional maxOrDefined(FloatOptional op1, FloatOptional op2) { +inline YGFloatOptional maxOrDefined(YGFloatOptional op1, YGFloatOptional op2) { if (op1 >= op2) { return op1; } diff --git a/yoga/numeric/FloatOptional.h b/yoga/numeric/FloatOptional.h deleted file mode 100644 index 89eff3b8..00000000 --- a/yoga/numeric/FloatOptional.h +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright (c) Meta Platforms, Inc. and affiliates. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ - -#pragma once - -#include -#include -#include - -namespace facebook::yoga { - -struct FloatOptional { -private: - float value_ = std::numeric_limits::quiet_NaN(); - -public: - explicit constexpr FloatOptional(float value) : value_(value) {} - constexpr FloatOptional() = default; - - // returns the wrapped value, or a value x with YGIsUndefined(x) == true - constexpr float unwrap() const { return value_; } - - bool isUndefined() const { return std::isnan(value_); } -}; - -// operators take FloatOptional by value, as it is a 32bit value - -inline bool operator==(FloatOptional lhs, FloatOptional rhs) { - return lhs.unwrap() == rhs.unwrap() || - (lhs.isUndefined() && rhs.isUndefined()); -} -inline bool operator!=(FloatOptional lhs, FloatOptional rhs) { - return !(lhs == rhs); -} - -inline bool operator==(FloatOptional lhs, float rhs) { - return lhs == FloatOptional{rhs}; -} -inline bool operator!=(FloatOptional lhs, float rhs) { - return !(lhs == rhs); -} - -inline bool operator==(float lhs, FloatOptional rhs) { - return rhs == lhs; -} -inline bool operator!=(float lhs, FloatOptional rhs) { - return !(lhs == rhs); -} - -inline FloatOptional operator+(FloatOptional lhs, FloatOptional rhs) { - return FloatOptional{lhs.unwrap() + rhs.unwrap()}; -} - -inline bool operator>(FloatOptional lhs, FloatOptional rhs) { - return lhs.unwrap() > rhs.unwrap(); -} - -inline bool operator<(FloatOptional lhs, FloatOptional rhs) { - return lhs.unwrap() < rhs.unwrap(); -} - -inline bool operator>=(FloatOptional lhs, FloatOptional rhs) { - return lhs > rhs || lhs == rhs; -} - -inline bool operator<=(FloatOptional lhs, FloatOptional rhs) { - return lhs < rhs || lhs == rhs; -} - -} // namespace facebook::yoga diff --git a/yoga/style/Style.h b/yoga/style/Style.h index 49bb8ece..c323346e 100644 --- a/yoga/style/Style.h +++ b/yoga/style/Style.h @@ -13,10 +13,10 @@ #include #include +#include #include #include -#include #include namespace facebook::yoga { @@ -105,9 +105,9 @@ private: uint32_t flags = 0; - FloatOptional flex_ = {}; - FloatOptional flexGrow_ = {}; - FloatOptional flexShrink_ = {}; + YGFloatOptional flex_ = {}; + YGFloatOptional flexGrow_ = {}; + YGFloatOptional flexShrink_ = {}; CompactValue flexBasis_ = CompactValue::ofAuto(); Edges margin_ = {}; Edges position_ = {}; @@ -118,7 +118,7 @@ private: Dimensions minDimensions_ = {}; Dimensions maxDimensions_ = {}; // Yoga specific properties, not compatible with flexbox specification - FloatOptional aspectRatio_ = {}; + YGFloatOptional aspectRatio_ = {}; public: // for library users needing a type @@ -187,14 +187,14 @@ public: } BitfieldRef display() { return {*this, displayOffset}; } - FloatOptional flex() const { return flex_; } - Ref flex() { return {*this}; } + YGFloatOptional flex() const { return flex_; } + Ref flex() { return {*this}; } - FloatOptional flexGrow() const { return flexGrow_; } - Ref flexGrow() { return {*this}; } + YGFloatOptional flexGrow() const { return flexGrow_; } + Ref flexGrow() { return {*this}; } - FloatOptional flexShrink() const { return flexShrink_; } - Ref flexShrink() { return {*this}; } + YGFloatOptional flexShrink() const { return flexShrink_; } + Ref flexShrink() { return {*this}; } CompactValue flexBasis() const { return flexBasis_; } Ref flexBasis() { return {*this}; } @@ -228,8 +228,8 @@ public: } // Yoga specific properties, not compatible with flexbox specification - FloatOptional aspectRatio() const { return aspectRatio_; } - Ref aspectRatio() { return {*this}; } + YGFloatOptional aspectRatio() const { return aspectRatio_; } + Ref aspectRatio() { return {*this}; } }; YOGA_EXPORT bool operator==(const Style& lhs, const Style& rhs);