Revert D48767992: C++ Cleanup 6/N: YGFloatOptional

Differential Revision:
D48767992

Original commit changeset: afaff0234359

Original Phabricator Diff: D48767992

fbshipit-source-id: 4666bdbb83aebbf2f7373b3a10a8c1dd0a03f92c

tests/YGFloatOptionalTest.cpp

@@ -8,19 +8,18 @@
 #include <gtest/gtest.h>
 
 #include <yoga/numeric/Comparison.h>
-#include <yoga/numeric/FloatOptional.h>
+#include <yoga/YGFloatOptional.h>
 #include <yoga/YGValue.h>
 
 using namespace facebook;
-using namespace facebook::yoga;
 
-constexpr auto empty = FloatOptional{};
+constexpr auto empty = YGFloatOptional{};
-constexpr auto zero = FloatOptional{0.0f};
+constexpr auto zero = YGFloatOptional{0.0f};
-constexpr auto one = FloatOptional{1.0f};
+constexpr auto one = YGFloatOptional{1.0f};
-constexpr auto positive = FloatOptional{1234.5f};
+constexpr auto positive = YGFloatOptional{1234.5f};
-constexpr auto negative = FloatOptional{-9876.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}),
+      yoga::maxOrDefined(YGFloatOptional{1.0f}, YGFloatOptional{1.125f}),
-      FloatOptional{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);
 }

tests/YGStyleAccessorsTest.cpp

@@ -154,24 +154,24 @@ ACCESSOR_TEST(display, YGDisplayFlex, YGDisplayNone, YGDisplayFlex)
 
 ACCESSOR_TEST(
     flex,
-    FloatOptional{},
+    YGFloatOptional{},
-    FloatOptional{123.45f},
+    YGFloatOptional{123.45f},
-    FloatOptional{-9.87f},
+    YGFloatOptional{-9.87f},
-    FloatOptional{})
+    YGFloatOptional{})
 
 ACCESSOR_TEST(
     flexGrow,
-    FloatOptional{},
+    YGFloatOptional{},
-    FloatOptional{123.45f},
+    YGFloatOptional{123.45f},
-    FloatOptional{-9.87f},
+    YGFloatOptional{-9.87f},
-    FloatOptional{})
+    YGFloatOptional{})
 
 ACCESSOR_TEST(
     flexShrink,
-    FloatOptional{},
+    YGFloatOptional{},
-    FloatOptional{123.45f},
+    YGFloatOptional{123.45f},
-    FloatOptional{-9.87f},
+    YGFloatOptional{-9.87f},
-    FloatOptional{})
+    YGFloatOptional{})
 
 ACCESSOR_TEST(
     flexBasis,
@@ -243,11 +243,11 @@ INDEX_ACCESSOR_TEST(
 
 ACCESSOR_TEST(
     aspectRatio,
-    FloatOptional{},
+    YGFloatOptional{},
-    FloatOptional{-123.45f},
+    YGFloatOptional{-123.45f},
-    FloatOptional{9876.5f},
+    YGFloatOptional{9876.5f},
-    FloatOptional{0.0f},
+    YGFloatOptional{0.0f},
-    FloatOptional{});
+    YGFloatOptional{});
 
 #endif
 

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 <cmath>
+#include <limits>
+#include <yoga/Yoga-internal.h>
+
+struct YGFloatOptional {
+private:
+  float value_ = std::numeric_limits<float>::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;
+}

yoga/Yoga.cpp

@@ -636,12 +636,12 @@ YOGA_EXPORT YGDisplay YGNodeStyleGetDisplay(const YGNodeConstRef node) {
   return static_cast<const yoga::Node*>(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<MSVC_HINT(flex)>(node, &Style::flex, FloatOptional{flex});
+  updateStyle<MSVC_HINT(flex)>(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<const yoga::Node*>(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<MSVC_HINT(flexGrow)>(
-      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<MSVC_HINT(flexShrink)>(
-      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<const yoga::Node*>(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<const yoga::Node*>(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<const yoga::Node*>(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<const yoga::Node*>(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<MSVC_HINT(aspectRatio)>(
-      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;
+  YGFloatOptional min;
-  FloatOptional max;
+  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 =
+    const YGFloatOptional paddingAndBorder =
-        FloatOptional(YGNodePaddingAndBorderForAxis(
+        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()),

yoga/algorithm/ResolveValue.h

@@ -8,22 +8,24 @@
 #pragma once
 
 #include <yoga/Yoga.h>
-#include <yoga/numeric/FloatOptional.h>
+#include <yoga/YGFloatOptional.h>
 
 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);
 }
 

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());
   }

yoga/node/LayoutResults.h

@@ -8,7 +8,7 @@
 #pragma once
 
 #include <yoga/BitUtils.h>
-#include <yoga/numeric/FloatOptional.h>
+#include <yoga/YGFloatOptional.h>
 #include <yoga/Yoga-internal.h>
 
 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

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() {

yoga/node/Node.h

@@ -66,7 +66,7 @@ private:
   std::array<YGValue, 2> 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);

yoga/numeric/Comparison.h

@@ -10,7 +10,7 @@
 #include <array>
 
 #include <yoga/Yoga.h>
-#include <yoga/numeric/FloatOptional.h>
+#include <yoga/YGFloatOptional.h>
 #include <yoga/style/CompactValue.h>
 
 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;
   }

yoga/numeric/FloatOptional.h

@@ -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 <cmath>
-#include <limits>
-#include <yoga/Yoga-internal.h>
-
-namespace facebook::yoga {
-
-struct FloatOptional {
-private:
-  float value_ = std::numeric_limits<float>::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

yoga/style/Style.h

@@ -13,10 +13,10 @@
 #include <type_traits>
 
 #include <yoga/Yoga.h>
+#include <yoga/YGFloatOptional.h>
 #include <yoga/Yoga-internal.h>
 #include <yoga/BitUtils.h>
 
-#include <yoga/numeric/FloatOptional.h>
 #include <yoga/style/CompactValue.h>
 
 namespace facebook::yoga {
@@ -105,9 +105,9 @@ private:
 
   uint32_t flags = 0;
 
-  FloatOptional flex_ = {};
+  YGFloatOptional flex_ = {};
-  FloatOptional flexGrow_ = {};
+  YGFloatOptional flexGrow_ = {};
-  FloatOptional flexShrink_ = {};
+  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<YGDisplay> display() { return {*this, displayOffset}; }
 
-  FloatOptional flex() const { return flex_; }
+  YGFloatOptional flex() const { return flex_; }
-  Ref<FloatOptional, &Style::flex_> flex() { return {*this}; }
+  Ref<YGFloatOptional, &Style::flex_> flex() { return {*this}; }
 
-  FloatOptional flexGrow() const { return flexGrow_; }
+  YGFloatOptional flexGrow() const { return flexGrow_; }
-  Ref<FloatOptional, &Style::flexGrow_> flexGrow() { return {*this}; }
+  Ref<YGFloatOptional, &Style::flexGrow_> flexGrow() { return {*this}; }
 
-  FloatOptional flexShrink() const { return flexShrink_; }
+  YGFloatOptional flexShrink() const { return flexShrink_; }
-  Ref<FloatOptional, &Style::flexShrink_> flexShrink() { return {*this}; }
+  Ref<YGFloatOptional, &Style::flexShrink_> flexShrink() { return {*this}; }
 
   CompactValue flexBasis() const { return flexBasis_; }
   Ref<CompactValue, &Style::flexBasis_> flexBasis() { return {*this}; }
@@ -228,8 +228,8 @@ public:
   }
 
   // Yoga specific properties, not compatible with flexbox specification
-  FloatOptional aspectRatio() const { return aspectRatio_; }
+  YGFloatOptional aspectRatio() const { return aspectRatio_; }
-  Ref<FloatOptional, &Style::aspectRatio_> aspectRatio() { return {*this}; }
+  Ref<YGFloatOptional, &Style::aspectRatio_> aspectRatio() { return {*this}; }
 };
 
 YOGA_EXPORT bool operator==(const Style& lhs, const Style& rhs);