From aeebf3afdff2cf457cd9820fb4b6e37f137fa3b6 Mon Sep 17 00:00:00 2001
From: Sidharth Guglani <sidharthguglani@fb.com>
Date: Fri, 22 Nov 2019 04:28:49 -0800
Subject: [PATCH] Remove Bitfield from YGStyle

Summary:
##Changelog:

[Internal][Yoga] Remove Bitfield from YGStyle

Reviewed By: astreet

Differential Revision: D18519614

fbshipit-source-id: 70f18bc679b62712d40d76bd793cf85906b067a1
---
 ReactCommon/yoga/yoga/YGStyle.h | 150 +++++++++++++++++++-------------
 1 file changed, 89 insertions(+), 61 deletions(-)

diff --git a/ReactCommon/yoga/yoga/YGStyle.h b/ReactCommon/yoga/yoga/YGStyle.h
index b066b34689..9bfbc4422c 100644
--- a/ReactCommon/yoga/yoga/YGStyle.h
+++ b/ReactCommon/yoga/yoga/YGStyle.h
@@ -10,12 +10,12 @@
 #include <array>
 #include <cstdint>
 #include <type_traits>
-#include "Bitfield.h"
 #include "CompactValue.h"
 #include "YGEnums.h"
 #include "YGFloatOptional.h"
 #include "Yoga-internal.h"
 #include "Yoga.h"
+#include "BitUtils.h"
 
 class YOGA_EXPORT YGStyle {
   template <typename Enum>
@@ -27,6 +27,19 @@ public:
   using Dimensions = Values<YGDimension>;
   using Edges = Values<YGEdge>;
 
+  template <typename T>
+  struct BitfieldRef {
+    YGStyle& style;
+    size_t offset;
+    operator T() const {
+      return facebook::yoga::detail::getEnumData<T>(style.flags, offset);
+    }
+    BitfieldRef<T>& operator=(T x) {
+      facebook::yoga::detail::setEnumData<T>(style.flags, offset, x);
+      return *this;
+    }
+  };
+
   template <typename T, T YGStyle::*Prop>
   struct Ref {
     YGStyle& style;
@@ -60,43 +73,35 @@ public:
     CompactValue operator[](Idx idx) const { return (style.*Prop)[idx]; }
   };
 
-  YGStyle() = default;
+  YGStyle() {
+    alignContent() = YGAlignFlexStart;
+    alignItems() = YGAlignStretch;
+  }
   ~YGStyle() = default;
 
 private:
-  static constexpr size_t directionIdx = 0;
-  static constexpr size_t flexDirectionIdx = 1;
-  static constexpr size_t justifyContentIdx = 2;
-  static constexpr size_t alignContentIdx = 3;
-  static constexpr size_t alignItemsIdx = 4;
-  static constexpr size_t alignSelfIdx = 5;
-  static constexpr size_t positionTypeIdx = 6;
-  static constexpr size_t flexWrapIdx = 7;
-  static constexpr size_t overflowIdx = 8;
-  static constexpr size_t displayIdx = 9;
-  using Flags = facebook::yoga::Bitfield<
-      uint32_t,
-      YGDirection,
-      YGFlexDirection,
-      YGJustify,
-      YGAlign,
-      YGAlign,
-      YGAlign,
-      YGPositionType,
-      YGWrap,
-      YGOverflow,
-      YGDisplay>;
+  static constexpr size_t directionOffset = 0;
+  static constexpr size_t flexdirectionOffset =
+      directionOffset + facebook::yoga::detail::bitWidthFn<YGDirection>();
+  static constexpr size_t justifyContentOffset = flexdirectionOffset +
+      facebook::yoga::detail::bitWidthFn<YGFlexDirection>();
+  static constexpr size_t alignContentOffset =
+      justifyContentOffset + facebook::yoga::detail::bitWidthFn<YGJustify>();
+  static constexpr size_t alignItemsOffset =
+      alignContentOffset + facebook::yoga::detail::bitWidthFn<YGAlign>();
+  static constexpr size_t alignSelfOffset =
+      alignItemsOffset + facebook::yoga::detail::bitWidthFn<YGAlign>();
+  static constexpr size_t positionTypeOffset =
+      alignSelfOffset + facebook::yoga::detail::bitWidthFn<YGAlign>();
+  static constexpr size_t flexWrapOffset =
+      positionTypeOffset + facebook::yoga::detail::bitWidthFn<YGPositionType>();
+  static constexpr size_t overflowOffset =
+      flexWrapOffset + facebook::yoga::detail::bitWidthFn<YGWrap>();
+  static constexpr size_t displayOffset =
+      overflowOffset + facebook::yoga::detail::bitWidthFn<YGOverflow>();
+
+  uint32_t flags = 0;
 
-  Flags flags_ = {YGDirectionInherit,
-                  YGFlexDirectionColumn,
-                  YGJustifyFlexStart,
-                  YGAlignFlexStart,
-                  YGAlignStretch,
-                  YGAlignAuto,
-                  YGPositionTypeRelative,
-                  YGWrapNoWrap,
-                  YGOverflowVisible,
-                  YGDisplayFlex};
   YGFloatOptional flex_ = {};
   YGFloatOptional flexGrow_ = {};
   YGFloatOptional flexShrink_ = {};
@@ -115,45 +120,68 @@ public:
   // for library users needing a type
   using ValueRepr = std::remove_reference<decltype(margin_[0])>::type;
 
-  YGDirection direction() const { return flags_.at<directionIdx>(); }
-  Flags::Ref<directionIdx> direction() { return flags_.at<directionIdx>(); }
+  YGDirection direction() const {
+    return facebook::yoga::detail::getEnumData<YGDirection>(
+        flags, directionOffset);
+  }
+  BitfieldRef<YGDirection> direction() { return {*this, directionOffset}; }
 
   YGFlexDirection flexDirection() const {
-    return flags_.at<flexDirectionIdx>();
+    return facebook::yoga::detail::getEnumData<YGFlexDirection>(
+        flags, flexdirectionOffset);
   }
-  Flags::Ref<flexDirectionIdx> flexDirection() {
-    return flags_.at<flexDirectionIdx>();
+  BitfieldRef<YGFlexDirection> flexDirection() {
+    return {*this, flexdirectionOffset};
   }
 
-  YGJustify justifyContent() const { return flags_.at<justifyContentIdx>(); }
-  Flags::Ref<justifyContentIdx> justifyContent() {
-    return flags_.at<justifyContentIdx>();
+  YGJustify justifyContent() const {
+    return facebook::yoga::detail::getEnumData<YGJustify>(
+        flags, justifyContentOffset);
+  }
+  BitfieldRef<YGJustify> justifyContent() {
+    return {*this, justifyContentOffset};
   }
 
-  YGAlign alignContent() const { return flags_.at<alignContentIdx>(); }
-  Flags::Ref<alignContentIdx> alignContent() {
-    return flags_.at<alignContentIdx>();
+  YGAlign alignContent() const {
+    return facebook::yoga::detail::getEnumData<YGAlign>(
+        flags, alignContentOffset);
+  }
+  BitfieldRef<YGAlign> alignContent() { return {*this, alignContentOffset}; }
+
+  YGAlign alignItems() const {
+    return facebook::yoga::detail::getEnumData<YGAlign>(
+        flags, alignItemsOffset);
+  }
+  BitfieldRef<YGAlign> alignItems() { return {*this, alignItemsOffset}; }
+
+  YGAlign alignSelf() const {
+    return facebook::yoga::detail::getEnumData<YGAlign>(flags, alignSelfOffset);
+  }
+  BitfieldRef<YGAlign> alignSelf() { return {*this, alignSelfOffset}; }
+
+  YGPositionType positionType() const {
+    return facebook::yoga::detail::getEnumData<YGPositionType>(
+        flags, positionTypeOffset);
+  }
+  BitfieldRef<YGPositionType> positionType() {
+    return {*this, positionTypeOffset};
   }
 
-  YGAlign alignItems() const { return flags_.at<alignItemsIdx>(); }
-  Flags::Ref<alignItemsIdx> alignItems() { return flags_.at<alignItemsIdx>(); }
-
-  YGAlign alignSelf() const { return flags_.at<alignSelfIdx>(); }
-  Flags::Ref<alignSelfIdx> alignSelf() { return flags_.at<alignSelfIdx>(); }
-
-  YGPositionType positionType() const { return flags_.at<positionTypeIdx>(); }
-  Flags::Ref<positionTypeIdx> positionType() {
-    return flags_.at<positionTypeIdx>();
+  YGWrap flexWrap() const {
+    return facebook::yoga::detail::getEnumData<YGWrap>(flags, flexWrapOffset);
   }
+  BitfieldRef<YGWrap> flexWrap() { return {*this, flexWrapOffset}; }
 
-  YGWrap flexWrap() const { return flags_.at<flexWrapIdx>(); }
-  Flags::Ref<flexWrapIdx> flexWrap() { return flags_.at<flexWrapIdx>(); }
+  YGOverflow overflow() const {
+    return facebook::yoga::detail::getEnumData<YGOverflow>(
+        flags, overflowOffset);
+  }
+  BitfieldRef<YGOverflow> overflow() { return {*this, overflowOffset}; }
 
-  YGOverflow overflow() const { return flags_.at<overflowIdx>(); }
-  Flags::Ref<overflowIdx> overflow() { return flags_.at<overflowIdx>(); }
-
-  YGDisplay display() const { return flags_.at<displayIdx>(); }
-  Flags::Ref<displayIdx> display() { return flags_.at<displayIdx>(); }
+  YGDisplay display() const {
+    return facebook::yoga::detail::getEnumData<YGDisplay>(flags, displayOffset);
+  }
+  BitfieldRef<YGDisplay> display() { return {*this, displayOffset}; }
 
   YGFloatOptional flex() const { return flex_; }
   Ref<YGFloatOptional, &YGStyle::flex_> flex() { return {*this}; }