C++ style enums 13/N: Wrap (#39539)

Summary:
Pull Request resolved: https://github.com/facebook/react-native/pull/39539

X-link: https://github.com/facebook/yoga/pull/1400

Moves internal usages of YGPositionType to PositionType

bypass-github-export-checks

Changelog: [Internal]

Reviewed By: rshest

Differential Revision: D49361746

fbshipit-source-id: ccc77b4c77753b5f41e11f1849d4c02153c190b7

packages/react-native/ReactCommon/react/renderer/components/view/conversions.h

@@ -333,26 +333,26 @@ inline void fromRawValue(
 inline void fromRawValue(
     const PropsParserContext& context,
     const RawValue& value,
-    YGWrap& result) {
-  result = YGWrapNoWrap;
+    yoga::Wrap& result) {
+  result = yoga::Wrap::NoWrap;
   react_native_expect(value.hasType<std::string>());
   if (!value.hasType<std::string>()) {
     return;
   }
   auto stringValue = (std::string)value;
   if (stringValue == "nowrap") {
-    result = YGWrapNoWrap;
+    result = yoga::Wrap::NoWrap;
     return;
   }
   if (stringValue == "wrap") {
-    result = YGWrapWrap;
+    result = yoga::Wrap::Wrap;
     return;
   }
   if (stringValue == "wrap-reverse") {
-    result = YGWrapWrapReverse;
+    result = yoga::Wrap::WrapReverse;
     return;
   }
-  LOG(ERROR) << "Could not parse YGWrap:" << stringValue;
+  LOG(ERROR) << "Could not parse yoga::Wrap:" << stringValue;
   react_native_expect(false);
 }
 
@@ -811,13 +811,13 @@ inline std::string toString(const yoga::PositionType& value) {
   }
 }
 
-inline std::string toString(const YGWrap& value) {
+inline std::string toString(const yoga::Wrap& value) {
   switch (value) {
-    case YGWrapNoWrap:
+    case yoga::Wrap::NoWrap:
       return "no-wrap";
-    case YGWrapWrap:
+    case yoga::Wrap::Wrap:
       return "wrap";
-    case YGWrapWrapReverse:
+    case yoga::Wrap::WrapReverse:
       return "wrap-reverse";
   }
 }

packages/react-native/ReactCommon/yoga/yoga/Yoga.cpp

@@ -492,10 +492,11 @@ YGPositionType YGNodeStyleGetPositionType(const YGNodeConstRef node) {
 }
 
 void YGNodeStyleSetFlexWrap(const YGNodeRef node, const YGWrap flexWrap) {
-  updateStyle<MSVC_HINT(flexWrap)>(node, &Style::flexWrap, flexWrap);
+  updateStyle<MSVC_HINT(flexWrap)>(
+      node, &Style::flexWrap, scopedEnum(flexWrap));
 }
 YGWrap YGNodeStyleGetFlexWrap(const YGNodeConstRef node) {
-  return resolveRef(node)->getStyle().flexWrap();
+  return unscopedEnum(resolveRef(node)->getStyle().flexWrap());
 }
 
 void YGNodeStyleSetOverflow(const YGNodeRef node, const YGOverflow overflow) {

packages/react-native/ReactCommon/yoga/yoga/algorithm/CalculateLayout.cpp

@@ -520,7 +520,7 @@ static void layoutAbsoluteChild(
   } else if (
       !child->isLeadingPositionDefined(crossAxis) &&
       ((resolveChildAlignment(node, child) == Align::FlexEnd) ^
-       (node->getStyle().flexWrap() == YGWrapWrapReverse))) {
+       (node->getStyle().flexWrap() == Wrap::WrapReverse))) {
     child->setLayoutPosition(
         (node->getLayout().measuredDimensions[dimension(crossAxis)] -
          child->getLayout().measuredDimensions[dimension(crossAxis)]),
@@ -877,7 +877,7 @@ static float distributeFreeSpaceSecondPass(
   float flexGrowFactor = 0;
   float deltaFreeSpace = 0;
   const bool isMainAxisRow = isRow(mainAxis);
-  const bool isNodeFlexWrap = node->getStyle().flexWrap() != YGWrapNoWrap;
+  const bool isNodeFlexWrap = node->getStyle().flexWrap() != Wrap::NoWrap;
 
   for (auto currentLineChild : flexLine.itemsInFlow) {
     childFlexBasis = boundAxisWithinMinAndMax(
@@ -1604,7 +1604,7 @@ static void calculateLayoutImpl(
       resolveDirection(node->getStyle().flexDirection(), direction);
   const FlexDirection crossAxis = resolveCrossDirection(mainAxis, direction);
   const bool isMainAxisRow = isRow(mainAxis);
-  const bool isNodeFlexWrap = node->getStyle().flexWrap() != YGWrapNoWrap;
+  const bool isNodeFlexWrap = node->getStyle().flexWrap() != Wrap::NoWrap;
 
   const float mainAxisownerSize = isMainAxisRow ? ownerWidth : ownerHeight;
   const float crossAxisownerSize = isMainAxisRow ? ownerHeight : ownerWidth;
@@ -2302,7 +2302,7 @@ static void calculateLayoutImpl(
 
   // As we only wrapped in normal direction yet, we need to reverse the
   // positions on wrap-reverse.
-  if (performLayout && node->getStyle().flexWrap() == YGWrapWrapReverse) {
+  if (performLayout && node->getStyle().flexWrap() == Wrap::WrapReverse) {
     for (size_t i = 0; i < childCount; i++) {
       const auto child = node->getChild(i);
       if (child->getStyle().positionType() != PositionType::Absolute) {

packages/react-native/ReactCommon/yoga/yoga/algorithm/FlexLine.cpp

@@ -32,7 +32,7 @@ FlexLine calculateFlexLine(
   float sizeConsumedIncludingMinConstraint = 0;
   const FlexDirection mainAxis = resolveDirection(
       node->getStyle().flexDirection(), node->resolveDirection(ownerDirection));
-  const bool isNodeFlexWrap = node->getStyle().flexWrap() != YGWrapNoWrap;
+  const bool isNodeFlexWrap = node->getStyle().flexWrap() != Wrap::NoWrap;
   const float gap = node->getGapForAxis(mainAxis, availableInnerWidth).unwrap();
 
   // Add items to the current line until it's full or we run out of items.

packages/react-native/ReactCommon/yoga/yoga/debug/NodeToString.cpp

@@ -166,8 +166,7 @@ void nodeToString(
     appendFloatOptionalIfDefined(str, "flex", style.flex());
 
     if (style.flexWrap() != yoga::Node{}.getStyle().flexWrap()) {
-      appendFormattedString(
-          str, "flex-wrap: %s; ", YGWrapToString(style.flexWrap()));
+      appendFormattedString(str, "flex-wrap: %s; ", toString(style.flexWrap()));
     }
 
     if (style.overflow() != yoga::Node{}.getStyle().overflow()) {

packages/react-native/ReactCommon/yoga/yoga/style/Style.h

@@ -20,6 +20,7 @@
 #include <yoga/enums/FlexDirection.h>
 #include <yoga/enums/Justify.h>
 #include <yoga/enums/PositionType.h>
+#include <yoga/enums/Wrap.h>
 #include <yoga/numeric/FloatOptional.h>
 #include <yoga/style/CompactValue.h>
 
@@ -119,7 +120,7 @@ class YG_EXPORT Style {
   static constexpr uint8_t flexWrapOffset =
       positionTypeOffset + minimumBitCount<PositionType>();
   static constexpr uint8_t overflowOffset =
-      flexWrapOffset + minimumBitCount<YGWrap>();
+      flexWrapOffset + minimumBitCount<Wrap>();
   static constexpr uint8_t displayOffset =
       overflowOffset + minimumBitCount<YGOverflow>();
 
@@ -193,10 +194,10 @@ class YG_EXPORT Style {
     return {*this, positionTypeOffset};
   }
 
-  YGWrap flexWrap() const {
-    return getEnumData<YGWrap>(flags, flexWrapOffset);
+  Wrap flexWrap() const {
+    return getEnumData<Wrap>(flags, flexWrapOffset);
   }
-  BitfieldRef<YGWrap> flexWrap() {
+  BitfieldRef<Wrap> flexWrap() {
     return {*this, flexWrapOffset};
   }