From 65d7f95901ed7057bd0cb5c15c1903cb2149cd67 Mon Sep 17 00:00:00 2001 From: Nick Gerleman Date: Wed, 30 Aug 2023 16:27:32 -0700 Subject: [PATCH] C++ Cleanup 1/N: Reorganize YGStyle (#1349) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Summary: X-link: https://github.com/facebook/react-native/pull/39221 Pull Request resolved: https://github.com/facebook/yoga/pull/1349 X-link: https://github.com/facebook/react-native/pull/39171 ## This diff This diff adds a `style` directory for code related to storing and manipulating styles. `YGStyle`, which is not a public API, is renamed to `yoga::Style` and moved into this folder, alongside `CompactValue`. We will eventually add `ValuePool` alongside this for the next generation style representation. ## This stack The organization of the C++ internals of Yoga are in need of attention. 1. Some of the C++ internals are namespaced, but others not. 2. Some of the namespaces include `detail`, but are meant to be used outside of the translation unit (FB Clang Tidy rules warn on any usage of these) 2. Most of the files are in a flat hierarchy, except for event tracing in its own folder 3. Some files and functions begin with YG, others don’t 4. Some functions are uppercase, others are not 5. Almost all of the interesting logic is in Yoga.cpp, and the file is too large to reason about 6. There are multiple grab bag files where folks put random functions they need in (Utils, BitUtils, Yoga-Internal.h) 7. There is no clear indication from file structure or type naming what is private vs not 8. Handles like `YGNodeRef` and `YGConfigRef` can be used to access internals just by importing headers This stack does some much needed spring cleaning: 1. All non-public headers and C++ implementation details are in separate folders from the root level `yoga`. This will give us room to split up logic and add more files without too large a flat hierarchy 3. All private C++ internals are under the `facebook::yoga` namespace. Details namespaces are only ever used within the same header, as they are intended 4. Utils files are split 5. Most C++ internals drop the YG prefix 6. Most C++ internal function names are all lower camel case 7. We start to split up Yoga.cpp 8. Every header beginning with YG or at the top-level directory is public and C only, with the exception of Yoga-Internal.h which has non-public functions for bindings 9. It is not possible to use private APIs without static casting handles to internal classes This will give us more leeway to continue splitting monolithic files, and consistent guidelines for style in new files as well. These changes should not be breaking to any project using only public Yoga headers. This includes every usage of Yoga in fbsource except for RN Fabric which is currently tied to internals. This refactor should make that boundary clearer. Changelog: [Internal] Reviewed By: shwanton Differential Revision: D48847261 fbshipit-source-id: 0fc8c6991e19079f3f0d55d368574757e453fe93 --- Yoga.podspec | 11 +- tests/CompactValueTest.cpp | 4 +- tests/YGStyleAccessorsTest.cpp | 31 +++--- yoga/Utils.h | 12 +- yoga/YGConfig.h | 4 +- yoga/YGFloatOptional.h | 2 +- yoga/YGLayout.h | 6 +- yoga/YGNode.cpp | 13 ++- yoga/YGNode.h | 25 +++-- yoga/YGNodePrint.cpp | 24 ++-- yoga/Yoga-internal.h | 2 +- yoga/Yoga.cpp | 154 ++++++++++++-------------- yoga/{ => style}/CompactValue.h | 4 +- yoga/{YGStyle.cpp => style/Style.cpp} | 10 +- yoga/{YGStyle.h => style/Style.h} | 63 +++++------ 15 files changed, 182 insertions(+), 183 deletions(-) rename yoga/{ => style}/CompactValue.h (98%) rename yoga/{YGStyle.cpp => style/Style.cpp} (93%) rename yoga/{YGStyle.h => style/Style.h} (80%) diff --git a/Yoga.podspec b/Yoga.podspec index bd050ade..4ebb5adf 100644 --- a/Yoga.podspec +++ b/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 diff --git a/tests/CompactValueTest.cpp b/tests/CompactValueTest.cpp index 5a875f8e..5b78a060 100644 --- a/tests/CompactValueTest.cpp +++ b/tests/CompactValueTest.cpp @@ -7,11 +7,11 @@ #define YOGA_COMPACT_VALUE_TEST -#include +#include #include #include -using facebook::yoga::detail::CompactValue; +using facebook::yoga::CompactValue; const auto tooSmall = nextafterf(CompactValue::LOWER_BOUND, -INFINITY); const auto tooLargePoints = diff --git a/tests/YGStyleAccessorsTest.cpp b/tests/YGStyleAccessorsTest.cpp index 2e96af92..49671bcc 100644 --- a/tests/YGStyleAccessorsTest.cpp +++ b/tests/YGStyleAccessorsTest.cpp @@ -8,9 +8,8 @@ #include #include #include -#include -#include -#include +#include +#include #define ACCESSOR_TESTS_1(NAME, X) \ style.NAME() = X; \ @@ -31,14 +30,14 @@ #define ACCESSOR_TESTS_N(a, b, c, d, e, COUNT, ...) ACCESSOR_TESTS_##COUNT #define ACCESSOR_TESTS(...) ACCESSOR_TESTS_N(__VA_ARGS__, 5, 4, 3, 2, 1) -#define INDEX_ACCESSOR_TESTS_1(NAME, IDX, X) \ - { \ - auto style = YGStyle{}; \ - style.NAME()[IDX] = X; \ - ASSERT_EQ(style.NAME()[IDX], X); \ - auto asArray = decltype(std::declval().NAME()){X}; \ - style.NAME() = asArray; \ - ASSERT_EQ(static_cast(style.NAME()), asArray); \ +#define INDEX_ACCESSOR_TESTS_1(NAME, IDX, X) \ + { \ + auto style = Style{}; \ + style.NAME()[IDX] = X; \ + ASSERT_EQ(style.NAME()[IDX], X); \ + auto asArray = decltype(std::declval().NAME()){X}; \ + style.NAME() = asArray; \ + ASSERT_EQ(static_cast(style.NAME()), asArray); \ } #define INDEX_ACCESSOR_TESTS_2(NAME, IDX, X, Y) \ @@ -64,22 +63,20 @@ // test macro for up to 5 values. If more are needed, extend the macros above. #define ACCESSOR_TEST(NAME, DEFAULT_VAL, ...) \ - TEST(YGStyle, style_##NAME##_access) { \ - auto style = YGStyle{}; \ + TEST(Style, style_##NAME##_access) { \ + auto style = Style{}; \ ASSERT_EQ(style.NAME(), DEFAULT_VAL); \ ACCESSOR_TESTS(__VA_ARGS__)(NAME, __VA_ARGS__) \ } #define INDEX_ACCESSOR_TEST(NAME, DEFAULT_VAL, IDX, ...) \ - TEST(YGStyle, style_##NAME##_access) { \ - ASSERT_EQ(YGStyle{}.NAME()[IDX], DEFAULT_VAL); \ + TEST(Style, style_##NAME##_access) { \ + ASSERT_EQ(Style{}.NAME()[IDX], DEFAULT_VAL); \ INDEX_ACCESSOR_TESTS(__VA_ARGS__)(NAME, IDX, __VA_ARGS__) \ } namespace facebook::yoga { -using CompactValue = detail::CompactValue; - // TODO: MSVC doesn't like the macros #ifndef _MSC_VER diff --git a/yoga/Utils.h b/yoga/Utils.h index 376c4fb5..78b44de6 100644 --- a/yoga/Utils.h +++ b/yoga/Utils.h @@ -8,8 +8,8 @@ #pragma once #include "YGNode.h" -#include "Yoga-internal.h" -#include "CompactValue.h" +#include +#include // This struct is an helper model to hold the data for step 4 of flexbox algo, // which is collecting the flex items in a line. @@ -56,8 +56,8 @@ struct YGCollectFlexItemsRowValues { bool YGValueEqual(const YGValue& a, const YGValue& b); inline bool YGValueEqual( - facebook::yoga::detail::CompactValue a, - facebook::yoga::detail::CompactValue b) { + facebook::yoga::CompactValue a, + facebook::yoga::CompactValue b) { return YGValueEqual((YGValue) a, (YGValue) b); } @@ -115,7 +115,7 @@ inline YGFloatOptional YGResolveValue( } inline YGFloatOptional YGResolveValue( - facebook::yoga::detail::CompactValue value, + facebook::yoga::CompactValue value, float ownerSize) { return YGResolveValue((YGValue) value, ownerSize); } @@ -140,7 +140,7 @@ inline YGFlexDirection YGResolveFlexDirection( } inline YGFloatOptional YGResolveValueMargin( - facebook::yoga::detail::CompactValue value, + facebook::yoga::CompactValue value, const float ownerSize) { return value.isAuto() ? YGFloatOptional{0} : YGResolveValue(value, ownerSize); } diff --git a/yoga/YGConfig.h b/yoga/YGConfig.h index 391e2500..fa530fab 100644 --- a/yoga/YGConfig.h +++ b/yoga/YGConfig.h @@ -9,8 +9,8 @@ #include -#include "BitUtils.h" -#include "Yoga-internal.h" +#include +#include namespace facebook::yoga { diff --git a/yoga/YGFloatOptional.h b/yoga/YGFloatOptional.h index 4aa9e76e..c4c18311 100644 --- a/yoga/YGFloatOptional.h +++ b/yoga/YGFloatOptional.h @@ -9,7 +9,7 @@ #include #include -#include "Yoga-internal.h" +#include struct YGFloatOptional { private: diff --git a/yoga/YGLayout.h b/yoga/YGLayout.h index 166eabb6..78a1bcf1 100644 --- a/yoga/YGLayout.h +++ b/yoga/YGLayout.h @@ -7,9 +7,9 @@ #pragma once -#include "BitUtils.h" -#include "YGFloatOptional.h" -#include "Yoga-internal.h" +#include +#include +#include struct YGLayout { std::array position = {}; diff --git a/yoga/YGNode.cpp b/yoga/YGNode.cpp index cd323b54..db537576 100644 --- a/yoga/YGNode.cpp +++ b/yoga/YGNode.cpp @@ -11,7 +11,8 @@ #include "Utils.h" using namespace facebook; -using facebook::yoga::detail::CompactValue; +using namespace facebook::yoga; +using facebook::yoga::CompactValue; YGNode::YGNode(const YGConfigRef config) : config_{config} { YGAssert( @@ -53,7 +54,7 @@ void YGNode::print(void* printContext) { } CompactValue YGNode::computeEdgeValueForRow( - const YGStyle::Edges& edges, + const Style::Edges& edges, YGEdge rowEdge, YGEdge edge, CompactValue defaultValue) { @@ -71,7 +72,7 @@ CompactValue YGNode::computeEdgeValueForRow( } CompactValue YGNode::computeEdgeValueForColumn( - const YGStyle::Edges& edges, + const Style::Edges& edges, YGEdge edge, CompactValue defaultValue) { if (!edges[edge].isUndefined()) { @@ -86,7 +87,7 @@ CompactValue YGNode::computeEdgeValueForColumn( } CompactValue YGNode::computeRowGap( - const YGStyle::Gutters& gutters, + const Style::Gutters& gutters, CompactValue defaultValue) { if (!gutters[YGGutterRow].isUndefined()) { return gutters[YGGutterRow]; @@ -98,7 +99,7 @@ CompactValue YGNode::computeRowGap( } CompactValue YGNode::computeColumnGap( - const YGStyle::Gutters& gutters, + const Style::Gutters& gutters, CompactValue defaultValue) { if (!gutters[YGGutterColumn].isUndefined()) { return gutters[YGGutterColumn]; @@ -431,7 +432,7 @@ YGValue YGNode::resolveFlexBasisPtr() const { void YGNode::resolveDimension() { using namespace yoga; - const YGStyle& style = getStyle(); + const Style& style = getStyle(); for (auto dim : {YGDimensionWidth, YGDimensionHeight}) { if (!style.maxDimensions()[dim].isUndefined() && YGValueEqual(style.maxDimensions()[dim], style.minDimensions()[dim])) { diff --git a/yoga/YGNode.h b/yoga/YGNode.h index e3c202f2..b46ce4aa 100644 --- a/yoga/YGNode.h +++ b/yoga/YGNode.h @@ -9,11 +9,12 @@ #include #include -#include "CompactValue.h" #include "YGConfig.h" #include "YGLayout.h" -#include "YGStyle.h" -#include "Yoga-internal.h" +#include + +#include +#include YGConfigRef YGConfigGetDefault(); @@ -52,7 +53,7 @@ private: PrintWithContextFn withContext; } print_ = {nullptr}; YGDirtiedFunc dirtied_ = nullptr; - YGStyle style_ = {}; + facebook::yoga::Style style_ = {}; YGLayout layout_ = {}; uint32_t lineIndex_ = 0; YGNodeRef owner_ = nullptr; @@ -80,7 +81,7 @@ private: // DO NOT CHANGE THE VISIBILITY OF THIS METHOD! YGNode& operator=(YGNode&&) = default; - using CompactValue = facebook::yoga::detail::CompactValue; + using CompactValue = facebook::yoga::CompactValue; public: YGNode() : YGNode{YGConfigGetDefault()} { flags_.hasNewLayout = true; } @@ -123,9 +124,9 @@ public: YGDirtiedFunc getDirtied() const { return dirtied_; } // For Performance reasons passing as reference. - YGStyle& getStyle() { return style_; } + facebook::yoga::Style& getStyle() { return style_; } - const YGStyle& getStyle() const { return style_; } + const facebook::yoga::Style& getStyle() const { return style_; } // For Performance reasons passing as reference. YGLayout& getLayout() { return layout_; } @@ -178,22 +179,22 @@ public: } static CompactValue computeEdgeValueForColumn( - const YGStyle::Edges& edges, + const facebook::yoga::Style::Edges& edges, YGEdge edge, CompactValue defaultValue); static CompactValue computeEdgeValueForRow( - const YGStyle::Edges& edges, + const facebook::yoga::Style::Edges& edges, YGEdge rowEdge, YGEdge edge, CompactValue defaultValue); static CompactValue computeRowGap( - const YGStyle::Gutters& gutters, + const facebook::yoga::Style::Gutters& gutters, CompactValue defaultValue); static CompactValue computeColumnGap( - const YGStyle::Gutters& gutters, + const facebook::yoga::Style::Gutters& gutters, CompactValue defaultValue); // Methods related to positions, margin, padding and border @@ -273,7 +274,7 @@ public: void setDirtiedFunc(YGDirtiedFunc dirtiedFunc) { dirtied_ = dirtiedFunc; } - void setStyle(const YGStyle& style) { style_ = style; } + void setStyle(const facebook::yoga::Style& style) { style_ = style; } void setLayout(const YGLayout& layout) { layout_ = layout; } diff --git a/yoga/YGNodePrint.cpp b/yoga/YGNodePrint.cpp index 7aa50f07..c1205abb 100644 --- a/yoga/YGNodePrint.cpp +++ b/yoga/YGNodePrint.cpp @@ -13,7 +13,7 @@ #include "YGNodePrint.h" #include "YGNode.h" -#include "Yoga-internal.h" +#include #include "Utils.h" namespace facebook::yoga { @@ -25,7 +25,7 @@ static void indent(string& base, uint32_t level) { } } -static bool areFourValuesEqual(const YGStyle::Edges& four) { +static bool areFourValuesEqual(const Style::Edges& four) { return YGValueEqual(four[0], four[1]) && YGValueEqual(four[0], four[2]) && YGValueEqual(four[0], four[3]); } @@ -90,10 +90,10 @@ static void appendNumberIfNotZero( static void appendEdges( string& base, const string& key, - const YGStyle::Edges& edges) { + const Style::Edges& edges) { if (areFourValuesEqual(edges)) { auto edgeValue = YGNode::computeEdgeValueForColumn( - edges, YGEdgeLeft, detail::CompactValue::ofZero()); + edges, YGEdgeLeft, CompactValue::ofZero()); appendNumberIfNotZero(base, key, edgeValue); } else { for (int edge = YGEdgeLeft; edge != YGEdgeAll; ++edge) { @@ -106,14 +106,14 @@ static void appendEdges( static void appendEdgeIfNotUndefined( string& base, const string& str, - const YGStyle::Edges& edges, + const Style::Edges& edges, const YGEdge edge) { // TODO: this doesn't take RTL / YGEdgeStart / YGEdgeEnd into account auto value = (edge == YGEdgeLeft || edge == YGEdgeRight) ? YGNode::computeEdgeValueForRow( - edges, edge, edge, detail::CompactValue::ofUndefined()) + edges, edge, edge, CompactValue::ofUndefined()) : YGNode::computeEdgeValueForColumn( - edges, edge, detail::CompactValue::ofUndefined()); + edges, edge, CompactValue::ofUndefined()); appendNumberIfNotUndefined(base, str, value); } @@ -188,17 +188,15 @@ void YGNodeToString( appendEdges(str, "padding", style.padding()); appendEdges(str, "border", style.border()); - if (YGNode::computeColumnGap( - style.gap(), detail::CompactValue::ofUndefined()) != + if (YGNode::computeColumnGap(style.gap(), CompactValue::ofUndefined()) != YGNode::computeColumnGap( - YGNode().getStyle().gap(), detail::CompactValue::ofUndefined())) { + YGNode().getStyle().gap(), CompactValue::ofUndefined())) { appendNumberIfNotUndefined( str, "column-gap", style.gap()[YGGutterColumn]); } - if (YGNode::computeRowGap( - style.gap(), detail::CompactValue::ofUndefined()) != + if (YGNode::computeRowGap(style.gap(), CompactValue::ofUndefined()) != YGNode::computeRowGap( - YGNode().getStyle().gap(), detail::CompactValue::ofUndefined())) { + YGNode().getStyle().gap(), CompactValue::ofUndefined())) { appendNumberIfNotUndefined(str, "row-gap", style.gap()[YGGutterRow]); } diff --git a/yoga/Yoga-internal.h b/yoga/Yoga-internal.h index c16c2ad5..d4e6df63 100644 --- a/yoga/Yoga-internal.h +++ b/yoga/Yoga-internal.h @@ -14,7 +14,7 @@ #include -#include "CompactValue.h" +#include using YGVector = std::vector; diff --git a/yoga/Yoga.cpp b/yoga/Yoga.cpp index ab0aa825..e8756ddf 100644 --- a/yoga/Yoga.cpp +++ b/yoga/Yoga.cpp @@ -17,7 +17,7 @@ #include "Utils.h" #include "YGNode.h" #include "YGNodePrint.h" -#include "Yoga-internal.h" +#include #include "event/event.h" using namespace facebook::yoga; @@ -480,26 +480,25 @@ void updateStyle( } template -void updateStyle(YGNode* node, Ref (YGStyle::*prop)(), T value) { +void updateStyle(YGNode* node, Ref (Style::*prop)(), T value) { updateStyle( node, value, - [prop](YGStyle& s, T x) { return (s.*prop)() != x; }, - [prop](YGStyle& s, T x) { (s.*prop)() = x; }); + [prop](Style& s, T x) { return (s.*prop)() != x; }, + [prop](Style& s, T x) { (s.*prop)() = x; }); } template void updateIndexedStyleProp( YGNode* node, - Ref (YGStyle::*prop)(), + Ref (Style::*prop)(), Idx idx, - detail::CompactValue value) { - using detail::CompactValue; + CompactValue value) { updateStyle( node, value, - [idx, prop](YGStyle& s, CompactValue x) { return (s.*prop)()[idx] != x; }, - [idx, prop](YGStyle& s, CompactValue x) { (s.*prop)()[idx] = x; }); + [idx, prop](Style& s, CompactValue x) { return (s.*prop)()[idx] != x; }, + [idx, prop](Style& s, CompactValue x) { (s.*prop)()[idx] = x; }); } } // namespace @@ -509,12 +508,12 @@ void updateIndexedStyleProp( // overload like clang and GCC. For the purposes of updateStyle(), we can help // MSVC by specifying that return type explicitly. In combination with // decltype, MSVC will prefer the non-const version. -#define MSVC_HINT(PROP) decltype(YGStyle{}.PROP()) +#define MSVC_HINT(PROP) decltype(Style{}.PROP()) YOGA_EXPORT void YGNodeStyleSetDirection( const YGNodeRef node, const YGDirection value) { - updateStyle(node, &YGStyle::direction, value); + updateStyle(node, &Style::direction, value); } YOGA_EXPORT YGDirection YGNodeStyleGetDirection(const YGNodeConstRef node) { return node->getStyle().direction(); @@ -524,7 +523,7 @@ YOGA_EXPORT void YGNodeStyleSetFlexDirection( const YGNodeRef node, const YGFlexDirection flexDirection) { updateStyle( - node, &YGStyle::flexDirection, flexDirection); + node, &Style::flexDirection, flexDirection); } YOGA_EXPORT YGFlexDirection YGNodeStyleGetFlexDirection(const YGNodeConstRef node) { @@ -535,7 +534,7 @@ YOGA_EXPORT void YGNodeStyleSetJustifyContent( const YGNodeRef node, const YGJustify justifyContent) { updateStyle( - node, &YGStyle::justifyContent, justifyContent); + node, &Style::justifyContent, justifyContent); } YOGA_EXPORT YGJustify YGNodeStyleGetJustifyContent(const YGNodeConstRef node) { return node->getStyle().justifyContent(); @@ -545,7 +544,7 @@ YOGA_EXPORT void YGNodeStyleSetAlignContent( const YGNodeRef node, const YGAlign alignContent) { updateStyle( - node, &YGStyle::alignContent, alignContent); + node, &Style::alignContent, alignContent); } YOGA_EXPORT YGAlign YGNodeStyleGetAlignContent(const YGNodeConstRef node) { return node->getStyle().alignContent(); @@ -554,7 +553,7 @@ YOGA_EXPORT YGAlign YGNodeStyleGetAlignContent(const YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetAlignItems( const YGNodeRef node, const YGAlign alignItems) { - updateStyle(node, &YGStyle::alignItems, alignItems); + updateStyle(node, &Style::alignItems, alignItems); } YOGA_EXPORT YGAlign YGNodeStyleGetAlignItems(const YGNodeConstRef node) { return node->getStyle().alignItems(); @@ -563,7 +562,7 @@ YOGA_EXPORT YGAlign YGNodeStyleGetAlignItems(const YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetAlignSelf( const YGNodeRef node, const YGAlign alignSelf) { - updateStyle(node, &YGStyle::alignSelf, alignSelf); + updateStyle(node, &Style::alignSelf, alignSelf); } YOGA_EXPORT YGAlign YGNodeStyleGetAlignSelf(const YGNodeConstRef node) { return node->getStyle().alignSelf(); @@ -573,7 +572,7 @@ YOGA_EXPORT void YGNodeStyleSetPositionType( const YGNodeRef node, const YGPositionType positionType) { updateStyle( - node, &YGStyle::positionType, positionType); + node, &Style::positionType, positionType); } YOGA_EXPORT YGPositionType YGNodeStyleGetPositionType(const YGNodeConstRef node) { @@ -583,7 +582,7 @@ YGNodeStyleGetPositionType(const YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetFlexWrap( const YGNodeRef node, const YGWrap flexWrap) { - updateStyle(node, &YGStyle::flexWrap, flexWrap); + updateStyle(node, &Style::flexWrap, flexWrap); } YOGA_EXPORT YGWrap YGNodeStyleGetFlexWrap(const YGNodeConstRef node) { return node->getStyle().flexWrap(); @@ -592,7 +591,7 @@ YOGA_EXPORT YGWrap YGNodeStyleGetFlexWrap(const YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetOverflow( const YGNodeRef node, const YGOverflow overflow) { - updateStyle(node, &YGStyle::overflow, overflow); + updateStyle(node, &Style::overflow, overflow); } YOGA_EXPORT YGOverflow YGNodeStyleGetOverflow(const YGNodeConstRef node) { return node->getStyle().overflow(); @@ -601,7 +600,7 @@ YOGA_EXPORT YGOverflow YGNodeStyleGetOverflow(const YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetDisplay( const YGNodeRef node, const YGDisplay display) { - updateStyle(node, &YGStyle::display, display); + updateStyle(node, &Style::display, display); } YOGA_EXPORT YGDisplay YGNodeStyleGetDisplay(const YGNodeConstRef node) { return node->getStyle().display(); @@ -609,7 +608,7 @@ YOGA_EXPORT YGDisplay YGNodeStyleGetDisplay(const YGNodeConstRef node) { // TODO(T26792433): Change the API to accept YGFloatOptional. YOGA_EXPORT void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) { - updateStyle(node, &YGStyle::flex, YGFloatOptional{flex}); + updateStyle(node, &Style::flex, YGFloatOptional{flex}); } // TODO(T26792433): Change the API to accept YGFloatOptional. @@ -624,7 +623,7 @@ YOGA_EXPORT void YGNodeStyleSetFlexGrow( const YGNodeRef node, const float flexGrow) { updateStyle( - node, &YGStyle::flexGrow, YGFloatOptional{flexGrow}); + node, &Style::flexGrow, YGFloatOptional{flexGrow}); } // TODO(T26792433): Change the API to accept YGFloatOptional. @@ -632,7 +631,7 @@ YOGA_EXPORT void YGNodeStyleSetFlexShrink( const YGNodeRef node, const float flexShrink) { updateStyle( - node, &YGStyle::flexShrink, YGFloatOptional{flexShrink}); + node, &Style::flexShrink, YGFloatOptional{flexShrink}); } YOGA_EXPORT YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) { @@ -647,37 +646,37 @@ YOGA_EXPORT YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetFlexBasis( const YGNodeRef node, const float flexBasis) { - auto value = detail::CompactValue::ofMaybe(flexBasis); - updateStyle(node, &YGStyle::flexBasis, value); + auto value = CompactValue::ofMaybe(flexBasis); + updateStyle(node, &Style::flexBasis, value); } YOGA_EXPORT void YGNodeStyleSetFlexBasisPercent( const YGNodeRef node, const float flexBasisPercent) { - auto value = detail::CompactValue::ofMaybe(flexBasisPercent); - updateStyle(node, &YGStyle::flexBasis, value); + auto value = CompactValue::ofMaybe(flexBasisPercent); + updateStyle(node, &Style::flexBasis, value); } YOGA_EXPORT void YGNodeStyleSetFlexBasisAuto(const YGNodeRef node) { updateStyle( - node, &YGStyle::flexBasis, detail::CompactValue::ofAuto()); + node, &Style::flexBasis, CompactValue::ofAuto()); } YOGA_EXPORT void YGNodeStyleSetPosition( YGNodeRef node, YGEdge edge, float points) { - auto value = detail::CompactValue::ofMaybe(points); + auto value = CompactValue::ofMaybe(points); updateIndexedStyleProp( - node, &YGStyle::position, edge, value); + node, &Style::position, edge, value); } YOGA_EXPORT void YGNodeStyleSetPositionPercent( YGNodeRef node, YGEdge edge, float percent) { - auto value = detail::CompactValue::ofMaybe(percent); + auto value = CompactValue::ofMaybe(percent); updateIndexedStyleProp( - node, &YGStyle::position, edge, value); + node, &Style::position, edge, value); } YOGA_EXPORT YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) { return node->getStyle().position()[edge]; @@ -687,21 +686,19 @@ YOGA_EXPORT void YGNodeStyleSetMargin( YGNodeRef node, YGEdge edge, float points) { - auto value = detail::CompactValue::ofMaybe(points); - updateIndexedStyleProp( - node, &YGStyle::margin, edge, value); + auto value = CompactValue::ofMaybe(points); + updateIndexedStyleProp(node, &Style::margin, edge, value); } YOGA_EXPORT void YGNodeStyleSetMarginPercent( YGNodeRef node, YGEdge edge, float percent) { - auto value = detail::CompactValue::ofMaybe(percent); - updateIndexedStyleProp( - node, &YGStyle::margin, edge, value); + auto value = CompactValue::ofMaybe(percent); + updateIndexedStyleProp(node, &Style::margin, edge, value); } YOGA_EXPORT void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge) { updateIndexedStyleProp( - node, &YGStyle::margin, edge, detail::CompactValue::ofAuto()); + node, &Style::margin, edge, CompactValue::ofAuto()); } YOGA_EXPORT YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge) { return node->getStyle().margin()[edge]; @@ -711,17 +708,17 @@ YOGA_EXPORT void YGNodeStyleSetPadding( YGNodeRef node, YGEdge edge, float points) { - auto value = detail::CompactValue::ofMaybe(points); + auto value = CompactValue::ofMaybe(points); updateIndexedStyleProp( - node, &YGStyle::padding, edge, value); + node, &Style::padding, edge, value); } YOGA_EXPORT void YGNodeStyleSetPaddingPercent( YGNodeRef node, YGEdge edge, float percent) { - auto value = detail::CompactValue::ofMaybe(percent); + auto value = CompactValue::ofMaybe(percent); updateIndexedStyleProp( - node, &YGStyle::padding, edge, value); + node, &Style::padding, edge, value); } YOGA_EXPORT YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge) { return node->getStyle().padding()[edge]; @@ -732,9 +729,8 @@ YOGA_EXPORT void YGNodeStyleSetBorder( const YGNodeRef node, const YGEdge edge, const float border) { - auto value = detail::CompactValue::ofMaybe(border); - updateIndexedStyleProp( - node, &YGStyle::border, edge, value); + auto value = CompactValue::ofMaybe(border); + updateIndexedStyleProp(node, &Style::border, edge, value); } YOGA_EXPORT float YGNodeStyleGetBorder( @@ -754,8 +750,8 @@ YOGA_EXPORT void YGNodeStyleSetGap( const YGNodeRef node, const YGGutter gutter, const float gapLength) { - auto length = detail::CompactValue::ofMaybe(gapLength); - updateIndexedStyleProp(node, &YGStyle::gap, gutter, length); + auto length = CompactValue::ofMaybe(gapLength); + updateIndexedStyleProp(node, &Style::gap, gutter, length); } YOGA_EXPORT float YGNodeStyleGetGap( @@ -784,46 +780,40 @@ YOGA_EXPORT void YGNodeStyleSetAspectRatio( const YGNodeRef node, const float aspectRatio) { updateStyle( - node, &YGStyle::aspectRatio, YGFloatOptional{aspectRatio}); + node, &Style::aspectRatio, YGFloatOptional{aspectRatio}); } YOGA_EXPORT void YGNodeStyleSetWidth(YGNodeRef node, float points) { - auto value = detail::CompactValue::ofMaybe(points); + auto value = CompactValue::ofMaybe(points); updateIndexedStyleProp( - node, &YGStyle::dimensions, YGDimensionWidth, value); + node, &Style::dimensions, YGDimensionWidth, value); } YOGA_EXPORT void YGNodeStyleSetWidthPercent(YGNodeRef node, float percent) { - auto value = detail::CompactValue::ofMaybe(percent); + auto value = CompactValue::ofMaybe(percent); updateIndexedStyleProp( - node, &YGStyle::dimensions, YGDimensionWidth, value); + node, &Style::dimensions, YGDimensionWidth, value); } YOGA_EXPORT void YGNodeStyleSetWidthAuto(YGNodeRef node) { updateIndexedStyleProp( - node, - &YGStyle::dimensions, - YGDimensionWidth, - detail::CompactValue::ofAuto()); + node, &Style::dimensions, YGDimensionWidth, CompactValue::ofAuto()); } YOGA_EXPORT YGValue YGNodeStyleGetWidth(YGNodeConstRef node) { return node->getStyle().dimensions()[YGDimensionWidth]; } YOGA_EXPORT void YGNodeStyleSetHeight(YGNodeRef node, float points) { - auto value = detail::CompactValue::ofMaybe(points); + auto value = CompactValue::ofMaybe(points); updateIndexedStyleProp( - node, &YGStyle::dimensions, YGDimensionHeight, value); + node, &Style::dimensions, YGDimensionHeight, value); } YOGA_EXPORT void YGNodeStyleSetHeightPercent(YGNodeRef node, float percent) { - auto value = detail::CompactValue::ofMaybe(percent); + auto value = CompactValue::ofMaybe(percent); updateIndexedStyleProp( - node, &YGStyle::dimensions, YGDimensionHeight, value); + node, &Style::dimensions, YGDimensionHeight, value); } YOGA_EXPORT void YGNodeStyleSetHeightAuto(YGNodeRef node) { updateIndexedStyleProp( - node, - &YGStyle::dimensions, - YGDimensionHeight, - detail::CompactValue::ofAuto()); + node, &Style::dimensions, YGDimensionHeight, CompactValue::ofAuto()); } YOGA_EXPORT YGValue YGNodeStyleGetHeight(YGNodeConstRef node) { return node->getStyle().dimensions()[YGDimensionHeight]; @@ -832,16 +822,16 @@ YOGA_EXPORT YGValue YGNodeStyleGetHeight(YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetMinWidth( const YGNodeRef node, const float minWidth) { - auto value = detail::CompactValue::ofMaybe(minWidth); + auto value = CompactValue::ofMaybe(minWidth); updateIndexedStyleProp( - node, &YGStyle::minDimensions, YGDimensionWidth, value); + node, &Style::minDimensions, YGDimensionWidth, value); } YOGA_EXPORT void YGNodeStyleSetMinWidthPercent( const YGNodeRef node, const float minWidth) { - auto value = detail::CompactValue::ofMaybe(minWidth); + auto value = CompactValue::ofMaybe(minWidth); updateIndexedStyleProp( - node, &YGStyle::minDimensions, YGDimensionWidth, value); + node, &Style::minDimensions, YGDimensionWidth, value); } YOGA_EXPORT YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) { return node->getStyle().minDimensions()[YGDimensionWidth]; @@ -850,16 +840,16 @@ YOGA_EXPORT YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetMinHeight( const YGNodeRef node, const float minHeight) { - auto value = detail::CompactValue::ofMaybe(minHeight); + auto value = CompactValue::ofMaybe(minHeight); updateIndexedStyleProp( - node, &YGStyle::minDimensions, YGDimensionHeight, value); + node, &Style::minDimensions, YGDimensionHeight, value); } YOGA_EXPORT void YGNodeStyleSetMinHeightPercent( const YGNodeRef node, const float minHeight) { - auto value = detail::CompactValue::ofMaybe(minHeight); + auto value = CompactValue::ofMaybe(minHeight); updateIndexedStyleProp( - node, &YGStyle::minDimensions, YGDimensionHeight, value); + node, &Style::minDimensions, YGDimensionHeight, value); } YOGA_EXPORT YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) { return node->getStyle().minDimensions()[YGDimensionHeight]; @@ -868,16 +858,16 @@ YOGA_EXPORT YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetMaxWidth( const YGNodeRef node, const float maxWidth) { - auto value = detail::CompactValue::ofMaybe(maxWidth); + auto value = CompactValue::ofMaybe(maxWidth); updateIndexedStyleProp( - node, &YGStyle::maxDimensions, YGDimensionWidth, value); + node, &Style::maxDimensions, YGDimensionWidth, value); } YOGA_EXPORT void YGNodeStyleSetMaxWidthPercent( const YGNodeRef node, const float maxWidth) { - auto value = detail::CompactValue::ofMaybe(maxWidth); + auto value = CompactValue::ofMaybe(maxWidth); updateIndexedStyleProp( - node, &YGStyle::maxDimensions, YGDimensionWidth, value); + node, &Style::maxDimensions, YGDimensionWidth, value); } YOGA_EXPORT YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) { return node->getStyle().maxDimensions()[YGDimensionWidth]; @@ -886,16 +876,16 @@ YOGA_EXPORT YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetMaxHeight( const YGNodeRef node, const float maxHeight) { - auto value = detail::CompactValue::ofMaybe(maxHeight); + auto value = CompactValue::ofMaybe(maxHeight); updateIndexedStyleProp( - node, &YGStyle::maxDimensions, YGDimensionHeight, value); + node, &Style::maxDimensions, YGDimensionHeight, value); } YOGA_EXPORT void YGNodeStyleSetMaxHeightPercent( const YGNodeRef node, const float maxHeight) { - auto value = detail::CompactValue::ofMaybe(maxHeight); + auto value = CompactValue::ofMaybe(maxHeight); updateIndexedStyleProp( - node, &YGStyle::maxDimensions, YGDimensionHeight, value); + node, &Style::maxDimensions, YGDimensionHeight, value); } YOGA_EXPORT YGValue YGNodeStyleGetMaxHeight(const YGNodeConstRef node) { return node->getStyle().maxDimensions()[YGDimensionHeight]; @@ -2519,7 +2509,7 @@ static void YGJustifyMainAxis( i < collectedFlexItemsValues.endOfLineIndex; i++) { const YGNodeRef child = node->getChild(i); - const YGStyle& childStyle = child->getStyle(); + const Style& childStyle = child->getStyle(); const YGLayout childLayout = child->getLayout(); const bool isLastChild = i == collectedFlexItemsValues.endOfLineIndex - 1; // remove the gap if it is the last element of the line diff --git a/yoga/CompactValue.h b/yoga/style/CompactValue.h similarity index 98% rename from yoga/CompactValue.h rename to yoga/style/CompactValue.h index 9d494500..498b984a 100644 --- a/yoga/CompactValue.h +++ b/yoga/style/CompactValue.h @@ -38,7 +38,7 @@ static_assert( #define VISIBLE_FOR_TESTING private: #endif -namespace facebook::yoga::detail { +namespace facebook::yoga { // This class stores YGValue in 32 bits. // - The value does not matter for Undefined and Auto. NaNs are used for their @@ -207,4 +207,4 @@ constexpr bool operator!=(CompactValue a, CompactValue b) noexcept { return !(a == b); } -} // namespace facebook::yoga::detail +} // namespace facebook::yoga diff --git a/yoga/YGStyle.cpp b/yoga/style/Style.cpp similarity index 93% rename from yoga/YGStyle.cpp rename to yoga/style/Style.cpp index 37153f2e..806f2428 100644 --- a/yoga/YGStyle.cpp +++ b/yoga/style/Style.cpp @@ -5,11 +5,13 @@ * LICENSE file in the root directory of this source tree. */ -#include "YGStyle.h" -#include "Utils.h" +#include +#include + +namespace facebook::yoga { // Yoga specific properties, not compatible with flexbox specification -bool operator==(const YGStyle& lhs, const YGStyle& rhs) { +bool operator==(const Style& lhs, const Style& rhs) { bool areNonFloatValuesEqual = lhs.direction() == rhs.direction() && lhs.flexDirection() == rhs.flexDirection() && lhs.justifyContent() == rhs.justifyContent() && @@ -54,3 +56,5 @@ bool operator==(const YGStyle& lhs, const YGStyle& rhs) { return areNonFloatValuesEqual; } + +} // namespace facebook::yoga diff --git a/yoga/YGStyle.h b/yoga/style/Style.h similarity index 80% rename from yoga/YGStyle.h rename to yoga/style/Style.h index 4f182d06..c323346e 100644 --- a/yoga/YGStyle.h +++ b/yoga/style/Style.h @@ -13,17 +13,17 @@ #include #include +#include +#include +#include -#include "CompactValue.h" -#include "YGFloatOptional.h" -#include "Yoga-internal.h" -#include "BitUtils.h" +#include -class YOGA_EXPORT YGStyle { +namespace facebook::yoga { + +class YOGA_EXPORT Style { template - using Values = - facebook::yoga::detail::Values()>; - using CompactValue = facebook::yoga::detail::CompactValue; + using Values = detail::Values()>; public: using Dimensions = Values; @@ -32,7 +32,7 @@ public: template struct BitfieldRef { - YGStyle& style; + Style& style; size_t offset; operator T() const { return facebook::yoga::detail::getEnumData(style.flags, offset); @@ -43,9 +43,9 @@ public: } }; - template + template struct Ref { - YGStyle& style; + Style& style; operator T() const { return style.*Prop; } Ref& operator=(T value) { style.*Prop = value; @@ -53,10 +53,10 @@ public: } }; - template YGStyle::*Prop> + template Style::*Prop> struct IdxRef { struct Ref { - YGStyle& style; + Style& style; Idx idx; operator CompactValue() const { return (style.*Prop)[idx]; } operator YGValue() const { return (style.*Prop)[idx]; } @@ -66,7 +66,7 @@ public: } }; - YGStyle& style; + Style& style; IdxRef& operator=(const Values& values) { style.*Prop = values; return *this; @@ -76,11 +76,11 @@ public: CompactValue operator[](Idx idx) const { return (style.*Prop)[idx]; } }; - YGStyle() { + Style() { alignContent() = YGAlignFlexStart; alignItems() = YGAlignStretch; } - ~YGStyle() = default; + ~Style() = default; private: static constexpr size_t directionOffset = 0; @@ -188,51 +188,52 @@ public: BitfieldRef display() { return {*this, displayOffset}; } YGFloatOptional flex() const { return flex_; } - Ref flex() { return {*this}; } + Ref flex() { return {*this}; } YGFloatOptional flexGrow() const { return flexGrow_; } - Ref flexGrow() { return {*this}; } + Ref flexGrow() { return {*this}; } YGFloatOptional flexShrink() const { return flexShrink_; } - Ref flexShrink() { return {*this}; } + Ref flexShrink() { return {*this}; } CompactValue flexBasis() const { return flexBasis_; } - Ref flexBasis() { return {*this}; } + Ref flexBasis() { return {*this}; } const Edges& margin() const { return margin_; } - IdxRef margin() { return {*this}; } + IdxRef margin() { return {*this}; } const Edges& position() const { return position_; } - IdxRef position() { return {*this}; } + IdxRef position() { return {*this}; } const Edges& padding() const { return padding_; } - IdxRef padding() { return {*this}; } + IdxRef padding() { return {*this}; } const Edges& border() const { return border_; } - IdxRef border() { return {*this}; } + IdxRef border() { return {*this}; } const Gutters& gap() const { return gap_; } - IdxRef gap() { return {*this}; } + IdxRef gap() { return {*this}; } const Dimensions& dimensions() const { return dimensions_; } - IdxRef dimensions() { return {*this}; } + IdxRef dimensions() { return {*this}; } const Dimensions& minDimensions() const { return minDimensions_; } - IdxRef minDimensions() { + IdxRef minDimensions() { return {*this}; } const Dimensions& maxDimensions() const { return maxDimensions_; } - IdxRef maxDimensions() { + IdxRef maxDimensions() { return {*this}; } // Yoga specific properties, not compatible with flexbox specification YGFloatOptional aspectRatio() const { return aspectRatio_; } - Ref aspectRatio() { return {*this}; } + Ref aspectRatio() { return {*this}; } }; -YOGA_EXPORT bool operator==(const YGStyle& lhs, const YGStyle& rhs); -YOGA_EXPORT inline bool operator!=(const YGStyle& lhs, const YGStyle& rhs) { +YOGA_EXPORT bool operator==(const Style& lhs, const Style& rhs); +YOGA_EXPORT inline bool operator!=(const Style& lhs, const Style& rhs) { return !(lhs == rhs); } +} // namespace facebook::yoga