C++ Cleanup 6/N: YGFloatOptional

Yoga.podspec

@@ -35,7 +35,14 @@ Pod::Spec.new do |spec|
       '-std=c++17',
       '-fPIC'
   ]
-  spec.source_files = 'yoga/**/*.{h,cpp}'
-  spec.public_header_files = 'yoga/{Yoga,YGEnums,YGMacros,YGValue}.h'
+
   spec.swift_version = '5.1'
+  spec.source_files = 'yoga/**/*.{h,cpp}'
+  spec.header_mappings_dir = 'yoga'
+
+  public_header_files = 'yoga/{Yoga,YGEnums,YGMacros,YGValue}.h'
+  spec.public_header_files = public_header_files
+
+  all_header_files = 'yoga/**/*.h'
+  spec.private_header_files = Dir.glob(all_header_files) - Dir.glob(public_header_files)
 end

java/jni/YGJNIVanilla.cpp

@@ -17,8 +17,10 @@
 
 // TODO: Reconcile missing layoutContext functionality from callbacks in the C
 // API and use that
-#include <yoga/YGNode.h>
+#include <yoga/node/Node.h>
 
+using namespace facebook;
+using namespace facebook::yoga;
 using namespace facebook::yoga::vanillajni;
 
 static inline ScopedLocalRef<jobject> YGNodeJobject(
@@ -194,7 +196,7 @@ static void jni_YGConfigSetLoggerJNI(
     }
 
     *context = newGlobalRef(env, logger);
-    config->setLogger(YGJNILogFunc);
+    static_cast<yoga::Config*>(config)->setLogger(YGJNILogFunc);
   } else {
     if (context != nullptr) {
       delete context;
@@ -686,7 +688,7 @@ static void jni_YGNodeSetHasMeasureFuncJNI(
     jobject /*obj*/,
     jlong nativePointer,
     jboolean hasMeasureFunc) {
-  _jlong2YGNodeRef(nativePointer)
+  static_cast<yoga::Node*>(_jlong2YGNodeRef(nativePointer))
       ->setMeasureFunc(hasMeasureFunc ? YGJNIMeasureFunc : nullptr);
 }
 
@@ -713,7 +715,7 @@ static void jni_YGNodeSetHasBaselineFuncJNI(
     jobject /*obj*/,
     jlong nativePointer,
     jboolean hasBaselineFunc) {
-  _jlong2YGNodeRef(nativePointer)
+  static_cast<yoga::Node*>(_jlong2YGNodeRef(nativePointer))
       ->setBaselineFunc(hasBaselineFunc ? YGJNIBaselineFunc : nullptr);
 }
 

java/jni/YGJTypesVanilla.h

@@ -14,11 +14,12 @@
 #include "jni.h"
 
 class PtrJNodeMapVanilla {
-  std::map<YGNodeRef, size_t> ptrsToIdxs_;
-  jobjectArray javaNodes_;
+  std::map<YGNodeConstRef, size_t> ptrsToIdxs_{};
+  jobjectArray javaNodes_{};
 
 public:
-  PtrJNodeMapVanilla() : ptrsToIdxs_{}, javaNodes_{} {}
+  PtrJNodeMapVanilla() = default;
+
   PtrJNodeMapVanilla(jlongArray javaNativePointers, jobjectArray javaNodes)
       : javaNodes_{javaNodes} {
     using namespace facebook::yoga::vanillajni;
@@ -30,11 +31,11 @@ class PtrJNodeMapVanilla {
         javaNativePointers, 0, nativePointersSize, nativePointers.data());
 
     for (size_t i = 0; i < nativePointersSize; ++i) {
-      ptrsToIdxs_[(YGNodeRef) nativePointers[i]] = i;
+      ptrsToIdxs_[(YGNodeConstRef) nativePointers[i]] = i;
     }
   }
 
-  facebook::yoga::vanillajni::ScopedLocalRef<jobject> ref(YGNodeRef node) {
+  facebook::yoga::vanillajni::ScopedLocalRef<jobject> ref(YGNodeConstRef node) {
     using namespace facebook::yoga::vanillajni;
 
     JNIEnv* env = getCurrentEnv();

tests/CompactValueTest.cpp

@@ -7,11 +7,11 @@
 
 #define YOGA_COMPACT_VALUE_TEST
 
-#include <yoga/CompactValue.h>
+#include <yoga/style/CompactValue.h>
 #include <gtest/gtest.h>
 #include <cmath>
 
-using facebook::yoga::detail::CompactValue;
+using facebook::yoga::CompactValue;
 
 const auto tooSmall = nextafterf(CompactValue::LOWER_BOUND, -INFINITY);
 const auto tooLargePoints =

tests/EventsTest.cpp

@@ -9,7 +9,6 @@
 #include <yoga/event/event.h>
 #include <yoga/Yoga.h>
 #include <yoga/YGEnums.h>
-#include <yoga/YGNode.h>
 
 #include <algorithm>
 #include <functional>
@@ -30,7 +29,7 @@ struct TypedEventTestData<Event::LayoutPassEnd> {
 };
 
 struct EventArgs {
-  const YGNode* node;
+  const YGNodeConstRef node;
   Event::Type type;
   std::unique_ptr<void, std::function<void(void*)>> dataPtr;
   std::unique_ptr<void, std::function<void(void*)>> eventTestDataPtr;
@@ -48,7 +47,7 @@ struct EventArgs {
 
 class EventTest : public ::testing::Test {
   ScopedEventSubscription subscription = {&EventTest::listen};
-  static void listen(const YGNode&, Event::Type, Event::Data);
+  static void listen(YGNodeConstRef, Event::Type, Event::Data);
 
 public:
   static std::vector<EventArgs> events;
@@ -284,16 +283,16 @@ TEST_F(EventTest, baseline_functions_get_wrapped) {
 namespace {
 
 template <Event::Type E>
-EventArgs createArgs(const YGNode& node, const Event::Data data) {
+EventArgs createArgs(YGNodeConstRef node, const Event::Data data) {
   using Data = Event::TypedData<E>;
   auto deleteData = [](void* x) { delete static_cast<Data*>(x); };
 
-  return {&node, E, {new Data{(data.get<E>())}, deleteData}, nullptr};
+  return {node, E, {new Data{(data.get<E>())}, deleteData}, nullptr};
 }
 
 template <Event::Type E>
 EventArgs createArgs(
-    const YGNode& node,
+    YGNodeConstRef node,
     const Event::Data data,
     TypedEventTestData<E> eventTestData) {
   using EventTestData = TypedEventTestData<E>;
@@ -309,7 +308,10 @@ EventArgs createArgs(
 
 } // namespace
 
-void EventTest::listen(const YGNode& node, Event::Type type, Event::Data data) {
+void EventTest::listen(
+    YGNodeConstRef node,
+    Event::Type type,
+    Event::Data data) {
   switch (type) {
     case Event::NodeAllocation:
       events.push_back(createArgs<Event::NodeAllocation>(node, data));

tests/YGFloatOptionalTest.cpp → tests/FloatOptionalTest.cpp

@@ -7,17 +7,20 @@
 
 #include <gtest/gtest.h>
 
-#include <yoga/Utils.h>
-#include <yoga/YGFloatOptional.h>
+#include <yoga/numeric/Comparison.h>
+#include <yoga/numeric/FloatOptional.h>
 #include <yoga/YGValue.h>
 
-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};
+using namespace facebook;
+using namespace facebook::yoga;
 
-TEST(YGFloatOptional, value) {
+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};
+
+TEST(FloatOptional, value) {
   ASSERT_TRUE(YGFloatIsUndefined(empty.unwrap()));
   ASSERT_EQ(zero.unwrap(), 0.0f);
   ASSERT_EQ(one.unwrap(), 1.0f);
@@ -31,7 +34,7 @@ TEST(YGFloatOptional, value) {
   ASSERT_FALSE(negative.isUndefined());
 }
 
-TEST(YGFloatOptional, equality) {
+TEST(FloatOptional, equality) {
   ASSERT_TRUE(empty == empty);
   ASSERT_TRUE(empty == YGUndefined);
   ASSERT_FALSE(empty == zero);
@@ -56,7 +59,7 @@ TEST(YGFloatOptional, equality) {
   ASSERT_FALSE(negative == zero);
 }
 
-TEST(YGFloatOptional, inequality) {
+TEST(FloatOptional, inequality) {
   ASSERT_FALSE(empty != empty);
   ASSERT_FALSE(empty != YGUndefined);
   ASSERT_TRUE(empty != zero);
@@ -81,7 +84,7 @@ TEST(YGFloatOptional, inequality) {
   ASSERT_TRUE(negative != zero);
 }
 
-TEST(YGFloatOptional, greater_than_with_undefined) {
+TEST(FloatOptional, greater_than_with_undefined) {
   ASSERT_FALSE(empty > empty);
   ASSERT_FALSE(empty > zero);
   ASSERT_FALSE(empty > one);
@@ -93,7 +96,7 @@ TEST(YGFloatOptional, greater_than_with_undefined) {
   ASSERT_FALSE(negative > empty);
 }
 
-TEST(YGFloatOptional, greater_than) {
+TEST(FloatOptional, greater_than) {
   ASSERT_TRUE(zero > negative);
   ASSERT_FALSE(zero > zero);
   ASSERT_FALSE(zero > positive);
@@ -103,10 +106,10 @@ TEST(YGFloatOptional, greater_than) {
   ASSERT_TRUE(one > zero);
   ASSERT_FALSE(one > positive);
 
-  ASSERT_TRUE(negative > YGFloatOptional{-INFINITY});
+  ASSERT_TRUE(negative > FloatOptional{-INFINITY});
 }
 
-TEST(YGFloatOptional, less_than_with_undefined) {
+TEST(FloatOptional, less_than_with_undefined) {
   ASSERT_FALSE(empty < empty);
   ASSERT_FALSE(zero < empty);
   ASSERT_FALSE(one < empty);
@@ -118,7 +121,7 @@ TEST(YGFloatOptional, less_than_with_undefined) {
   ASSERT_FALSE(empty < negative);
 }
 
-TEST(YGFloatOptional, less_than) {
+TEST(FloatOptional, less_than) {
   ASSERT_TRUE(negative < zero);
   ASSERT_FALSE(zero < zero);
   ASSERT_FALSE(positive < zero);
@@ -128,10 +131,10 @@ TEST(YGFloatOptional, less_than) {
   ASSERT_TRUE(zero < one);
   ASSERT_FALSE(positive < one);
 
-  ASSERT_TRUE(YGFloatOptional{-INFINITY} < negative);
+  ASSERT_TRUE(FloatOptional{-INFINITY} < negative);
 }
 
-TEST(YGFloatOptional, greater_than_equals_with_undefined) {
+TEST(FloatOptional, greater_than_equals_with_undefined) {
   ASSERT_TRUE(empty >= empty);
   ASSERT_FALSE(empty >= zero);
   ASSERT_FALSE(empty >= one);
@@ -143,7 +146,7 @@ TEST(YGFloatOptional, greater_than_equals_with_undefined) {
   ASSERT_FALSE(negative >= empty);
 }
 
-TEST(YGFloatOptional, greater_than_equals) {
+TEST(FloatOptional, greater_than_equals) {
   ASSERT_TRUE(zero >= negative);
   ASSERT_TRUE(zero >= zero);
   ASSERT_FALSE(zero >= positive);
@@ -153,10 +156,10 @@ TEST(YGFloatOptional, greater_than_equals) {
   ASSERT_TRUE(one >= zero);
   ASSERT_FALSE(one >= positive);
 
-  ASSERT_TRUE(negative >= YGFloatOptional{-INFINITY});
+  ASSERT_TRUE(negative >= FloatOptional{-INFINITY});
 }
 
-TEST(YGFloatOptional, less_than_equals_with_undefined) {
+TEST(FloatOptional, less_than_equals_with_undefined) {
   ASSERT_TRUE(empty <= empty);
   ASSERT_FALSE(zero <= empty);
   ASSERT_FALSE(one <= empty);
@@ -168,7 +171,7 @@ TEST(YGFloatOptional, less_than_equals_with_undefined) {
   ASSERT_FALSE(empty <= negative);
 }
 
-TEST(YGFloatOptional, less_than_equals) {
+TEST(FloatOptional, less_than_equals) {
   ASSERT_TRUE(negative <= zero);
   ASSERT_TRUE(zero <= zero);
   ASSERT_FALSE(positive <= zero);
@@ -178,32 +181,32 @@ TEST(YGFloatOptional, less_than_equals) {
   ASSERT_TRUE(zero <= one);
   ASSERT_FALSE(positive <= one);
 
-  ASSERT_TRUE(YGFloatOptional{-INFINITY} <= negative);
+  ASSERT_TRUE(FloatOptional{-INFINITY} <= negative);
 }
 
-TEST(YGFloatOptional, addition) {
+TEST(FloatOptional, addition) {
   auto n = negative.unwrap();
   auto p = positive.unwrap();
 
   ASSERT_EQ(zero + one, one);
-  ASSERT_EQ(negative + positive, YGFloatOptional{n + p});
+  ASSERT_EQ(negative + positive, FloatOptional{n + p});
   ASSERT_EQ(empty + zero, empty);
   ASSERT_EQ(empty + empty, empty);
   ASSERT_EQ(negative + empty, empty);
 }
 
-TEST(YGFloatOptionalTest, YGFloatOptionalMax) {
-  ASSERT_EQ(YGFloatOptionalMax(empty, empty), empty);
-  ASSERT_EQ(YGFloatOptionalMax(empty, positive), positive);
-  ASSERT_EQ(YGFloatOptionalMax(negative, empty), negative);
-  ASSERT_EQ(YGFloatOptionalMax(negative, YGFloatOptional{-INFINITY}), negative);
+TEST(YGFloatOptiona, 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(
-      YGFloatOptionalMax(YGFloatOptional{1.0f}, YGFloatOptional{1.125f}),
-      YGFloatOptional{1.125f});
+      yoga::maxOrDefined(FloatOptional{1.0f}, FloatOptional{1.125f}),
+      FloatOptional{1.125f});
 }
 
-TEST(YGFloatOptionalTest, unwrap) {
+TEST(FloatOptional, unwrap) {
   ASSERT_TRUE(YGFloatIsUndefined(empty.unwrap()));
   ASSERT_EQ(zero.unwrap(), 0.0f);
-  ASSERT_EQ(YGFloatOptional{123456.78f}.unwrap(), 123456.78f);
+  ASSERT_EQ(FloatOptional{123456.78f}.unwrap(), 123456.78f);
 }