Revert D48768374: C++ Cleanup 7/N: BitUtils

Differential Revision:
D48768374

Original commit changeset: 921a22ec88bd

Original Phabricator Diff: D48768374

fbshipit-source-id: 59106ab3d03619940023dac1c2af62fd88566773

yoga/BitUtils.h

@@ -13,7 +13,11 @@
 
 #include <yoga/YGEnums.h>
 
-namespace facebook::yoga::details {
+namespace facebook::yoga::detail {
+
+// std::bitset with one bit for each option defined in YG_ENUM_SEQ_DECL
+template <typename Enum>
+using EnumBitset = std::bitset<facebook::yoga::enums::count<Enum>()>;
 
 constexpr size_t log2ceilFn(size_t n) {
   return n < 1 ? 0 : (1 + log2ceilFn(n / 2));
@@ -23,37 +27,30 @@ constexpr int mask(size_t bitWidth, size_t index) {
   return ((1 << bitWidth) - 1) << index;
 }
 
-} // namespace facebook::yoga::details
-
-namespace facebook::yoga {
-
 // The number of bits necessary to represent enums defined with YG_ENUM_SEQ_DECL
 template <typename Enum>
-constexpr size_t minimumBitCount() {
+constexpr size_t bitWidthFn() {
   static_assert(
       enums::count<Enum>() > 0, "Enums must have at least one entries");
-  return details::log2ceilFn(enums::count<Enum>() - 1);
+  return log2ceilFn(enums::count<Enum>() - 1);
 }
 
 template <typename Enum>
 constexpr Enum getEnumData(int flags, size_t index) {
-  return static_cast<Enum>(
-      (flags & details::mask(minimumBitCount<Enum>(), index)) >> index);
+  return static_cast<Enum>((flags & mask(bitWidthFn<Enum>(), index)) >> index);
 }
 
 template <typename Enum>
 void setEnumData(uint32_t& flags, size_t index, int newValue) {
-  flags = (flags & ~details::mask(minimumBitCount<Enum>(), index)) |
-      ((newValue << index) & (details::mask(minimumBitCount<Enum>(), index)));
+  flags = (flags & ~mask(bitWidthFn<Enum>(), index)) |
+      ((newValue << index) & (mask(bitWidthFn<Enum>(), index)));
 }
 
 template <typename Enum>
 void setEnumData(uint8_t& flags, size_t index, int newValue) {
-  flags =
-      (flags &
-       ~static_cast<uint8_t>(details::mask(minimumBitCount<Enum>(), index))) |
+  flags = (flags & ~static_cast<uint8_t>(mask(bitWidthFn<Enum>(), index))) |
       ((newValue << index) &
-       (static_cast<uint8_t>(details::mask(minimumBitCount<Enum>(), index))));
+       (static_cast<uint8_t>(mask(bitWidthFn<Enum>(), index))));
 }
 
 constexpr bool getBooleanData(int flags, size_t index) {
@@ -68,4 +65,4 @@ inline void setBooleanData(uint8_t& flags, size_t index, bool value) {
   }
 }
 
-} // namespace facebook::yoga
+} // namespace facebook::yoga::detail

yoga/bits/EnumBitset.h

@@ -1,19 +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 <bitset>
-#include <yoga/YGEnums.h>
-
-namespace facebook::yoga {
-
-// std::bitset with one bit for each option defined in YG_ENUM_SEQ_DECL
-template <typename Enum>
-using EnumBitset = std::bitset<enums::count<Enum>()>;
-
-} // namespace facebook::yoga

yoga/config/Config.cpp

@@ -46,7 +46,7 @@ bool Config::isExperimentalFeatureEnabled(YGExperimentalFeature feature) const {
   return experimentalFeatures_.test(feature);
 }
 
-EnumBitset<YGExperimentalFeature> Config::getEnabledExperiments() const {
+ExperimentalFeatureSet Config::getEnabledExperiments() const {
   return experimentalFeatures_;
 }
 

yoga/config/Config.h

@@ -9,7 +9,7 @@
 
 #include <yoga/Yoga.h>
 
-#include <yoga/bits/EnumBitset.h>
+#include <yoga/BitUtils.h>
 #include <yoga/Yoga-internal.h>
 
 // Tag struct used to form the opaque YGConfigRef for the public C API
@@ -38,6 +38,8 @@ using CloneWithContextFn = YGNodeRef (*)(
     int childIndex,
     void* cloneContext);
 
+using ExperimentalFeatureSet = detail::EnumBitset<YGExperimentalFeature>;
+
 #pragma pack(push)
 #pragma pack(1)
 // Packed structure of <32-bit options to miminize size per node.
@@ -63,7 +65,7 @@ public:
       YGExperimentalFeature feature,
       bool enabled);
   bool isExperimentalFeatureEnabled(YGExperimentalFeature feature) const;
-  EnumBitset<YGExperimentalFeature> getEnabledExperiments() const;
+  ExperimentalFeatureSet getEnabledExperiments() const;
 
   void setErrata(YGErrata errata);
   void addErrata(YGErrata errata);
@@ -102,7 +104,7 @@ private:
   } logger_;
 
   ConfigFlags flags_{};
-  EnumBitset<YGExperimentalFeature> experimentalFeatures_{};
+  ExperimentalFeatureSet experimentalFeatures_{};
   YGErrata errata_ = YGErrataNone;
   float pointScaleFactor_ = 1.0f;
   void* context_ = nullptr;

yoga/node/LayoutResults.h

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include <yoga/bits/NumericBitfield.h>
+#include <yoga/BitUtils.h>
 #include <yoga/numeric/FloatOptional.h>
 #include <yoga/Yoga-internal.h>
 
@@ -23,7 +23,7 @@ struct LayoutResults {
 private:
   static constexpr size_t directionOffset = 0;
   static constexpr size_t hadOverflowOffset =
-      directionOffset + minimumBitCount<YGDirection>();
+      directionOffset + facebook::yoga::detail::bitWidthFn<YGDirection>();
   uint8_t flags = 0;
 
 public:
@@ -43,16 +43,21 @@ public:
   YGCachedMeasurement cachedLayout = YGCachedMeasurement();
 
   YGDirection direction() const {
-    return getEnumData<YGDirection>(flags, directionOffset);
+    return facebook::yoga::detail::getEnumData<YGDirection>(
+        flags, directionOffset);
   }
 
   void setDirection(YGDirection direction) {
-    setEnumData<YGDirection>(flags, directionOffset, direction);
+    facebook::yoga::detail::setEnumData<YGDirection>(
+        flags, directionOffset, direction);
   }
 
-  bool hadOverflow() const { return getBooleanData(flags, hadOverflowOffset); }
+  bool hadOverflow() const {
+    return facebook::yoga::detail::getBooleanData(flags, hadOverflowOffset);
+  }
   void setHadOverflow(bool hadOverflow) {
-    setBooleanData(flags, hadOverflowOffset, hadOverflow);
+    facebook::yoga::detail::setBooleanData(
+        flags, hadOverflowOffset, hadOverflow);
   }
 
   bool operator==(LayoutResults layout) const;

yoga/style/Style.h

@@ -14,8 +14,8 @@
 
 #include <yoga/Yoga.h>
 #include <yoga/Yoga-internal.h>
+#include <yoga/BitUtils.h>
 
-#include <yoga/bits/NumericBitfield.h>
 #include <yoga/numeric/FloatOptional.h>
 #include <yoga/style/CompactValue.h>
 
@@ -34,9 +34,11 @@ public:
   struct BitfieldRef {
     Style& style;
     size_t offset;
-    operator T() const { return getEnumData<T>(style.flags, offset); }
+    operator T() const {
+      return facebook::yoga::detail::getEnumData<T>(style.flags, offset);
+    }
     BitfieldRef<T>& operator=(T x) {
-      setEnumData<T>(style.flags, offset, x);
+      facebook::yoga::detail::setEnumData<T>(style.flags, offset, x);
       return *this;
     }
   };
@@ -83,23 +85,23 @@ public:
 private:
   static constexpr size_t directionOffset = 0;
   static constexpr size_t flexdirectionOffset =
-      directionOffset + minimumBitCount<YGDirection>();
-  static constexpr size_t justifyContentOffset =
-      flexdirectionOffset + minimumBitCount<YGFlexDirection>();
+      directionOffset + facebook::yoga::detail::bitWidthFn<YGDirection>();
+  static constexpr size_t justifyContentOffset = flexdirectionOffset +
+      facebook::yoga::detail::bitWidthFn<YGFlexDirection>();
   static constexpr size_t alignContentOffset =
-      justifyContentOffset + minimumBitCount<YGJustify>();
+      justifyContentOffset + facebook::yoga::detail::bitWidthFn<YGJustify>();
   static constexpr size_t alignItemsOffset =
-      alignContentOffset + minimumBitCount<YGAlign>();
+      alignContentOffset + facebook::yoga::detail::bitWidthFn<YGAlign>();
   static constexpr size_t alignSelfOffset =
-      alignItemsOffset + minimumBitCount<YGAlign>();
+      alignItemsOffset + facebook::yoga::detail::bitWidthFn<YGAlign>();
   static constexpr size_t positionTypeOffset =
-      alignSelfOffset + minimumBitCount<YGAlign>();
+      alignSelfOffset + facebook::yoga::detail::bitWidthFn<YGAlign>();
   static constexpr size_t flexWrapOffset =
-      positionTypeOffset + minimumBitCount<YGPositionType>();
+      positionTypeOffset + facebook::yoga::detail::bitWidthFn<YGPositionType>();
   static constexpr size_t overflowOffset =
-      flexWrapOffset + minimumBitCount<YGWrap>();
+      flexWrapOffset + facebook::yoga::detail::bitWidthFn<YGWrap>();
   static constexpr size_t displayOffset =
-      overflowOffset + minimumBitCount<YGOverflow>();
+      overflowOffset + facebook::yoga::detail::bitWidthFn<YGOverflow>();
 
   uint32_t flags = 0;
 
@@ -123,56 +125,65 @@ public:
   using ValueRepr = std::remove_reference<decltype(margin_[0])>::type;
 
   YGDirection direction() const {
-    return getEnumData<YGDirection>(flags, directionOffset);
+    return facebook::yoga::detail::getEnumData<YGDirection>(
+        flags, directionOffset);
   }
   BitfieldRef<YGDirection> direction() { return {*this, directionOffset}; }
 
   YGFlexDirection flexDirection() const {
-    return getEnumData<YGFlexDirection>(flags, flexdirectionOffset);
+    return facebook::yoga::detail::getEnumData<YGFlexDirection>(
+        flags, flexdirectionOffset);
   }
   BitfieldRef<YGFlexDirection> flexDirection() {
     return {*this, flexdirectionOffset};
   }
 
   YGJustify justifyContent() const {
-    return getEnumData<YGJustify>(flags, justifyContentOffset);
+    return facebook::yoga::detail::getEnumData<YGJustify>(
+        flags, justifyContentOffset);
   }
   BitfieldRef<YGJustify> justifyContent() {
     return {*this, justifyContentOffset};
   }
 
   YGAlign alignContent() const {
-    return getEnumData<YGAlign>(flags, alignContentOffset);
+    return facebook::yoga::detail::getEnumData<YGAlign>(
+        flags, alignContentOffset);
   }
   BitfieldRef<YGAlign> alignContent() { return {*this, alignContentOffset}; }
 
   YGAlign alignItems() const {
-    return getEnumData<YGAlign>(flags, alignItemsOffset);
+    return facebook::yoga::detail::getEnumData<YGAlign>(
+        flags, alignItemsOffset);
   }
   BitfieldRef<YGAlign> alignItems() { return {*this, alignItemsOffset}; }
 
   YGAlign alignSelf() const {
-    return getEnumData<YGAlign>(flags, alignSelfOffset);
+    return facebook::yoga::detail::getEnumData<YGAlign>(flags, alignSelfOffset);
   }
   BitfieldRef<YGAlign> alignSelf() { return {*this, alignSelfOffset}; }
 
   YGPositionType positionType() const {
-    return getEnumData<YGPositionType>(flags, positionTypeOffset);
+    return facebook::yoga::detail::getEnumData<YGPositionType>(
+        flags, positionTypeOffset);
   }
   BitfieldRef<YGPositionType> positionType() {
     return {*this, positionTypeOffset};
   }
 
-  YGWrap flexWrap() const { return getEnumData<YGWrap>(flags, flexWrapOffset); }
+  YGWrap flexWrap() const {
+    return facebook::yoga::detail::getEnumData<YGWrap>(flags, flexWrapOffset);
+  }
   BitfieldRef<YGWrap> flexWrap() { return {*this, flexWrapOffset}; }
 
   YGOverflow overflow() const {
-    return getEnumData<YGOverflow>(flags, overflowOffset);
+    return facebook::yoga::detail::getEnumData<YGOverflow>(
+        flags, overflowOffset);
   }
   BitfieldRef<YGOverflow> overflow() { return {*this, overflowOffset}; }
 
   YGDisplay display() const {
-    return getEnumData<YGDisplay>(flags, displayOffset);
+    return facebook::yoga::detail::getEnumData<YGDisplay>(flags, displayOffset);
   }
   BitfieldRef<YGDisplay> display() { return {*this, displayOffset}; }