DaddyFrosty/yoga
1
0
Fork 0
Code Issues 96 Pull Requests 31 Actions Packages Projects Releases 33 Wiki Activity

Allow lazy resolution of edge dimension values (#1453)

Browse Source 
Summary:
X-link: https://github.com/facebook/react-native/pull/41347

Pull Request resolved: https://github.com/facebook/yoga/pull/1453

This follows the previous patterns used for `Gutters` and `Dimension`, where we hide CompactValue array implementation from `yoga::Style` callers.

This allows a single read of a style to only need access to the resolved values of a single edge, vs all edges. This is cheap now because the interface is the representation, but gets expensive if `StyleValuePool` is the actual implementation.

This prevents us from needing to resolve nine dimensions, in order to read a single value like `marginLeft`. Doing this, in the new style, also lets us remove `IdxRef` from the API.

We unroll the structure dependent parts in the props parsing code, for something more verbose, but also a bit clearer.

Changelog: [Internal]

Reviewed By: joevilches

Differential Revision: D50998164

fbshipit-source-id: 248396f9587e29d62cde05ae7512d8194f60c809
This commit is contained in:
Nick Gerleman
2023-11-14 09:12:35 -08:00
committed by Facebook GitHub Bot
parent bb892af3a4
commit f2c8acad2c
9 changed files with 124 additions and 416 deletions
Download Patch File Download Diff File Expand all files Collapse all files

216
tests/YGStyleAccessorsTest.cpp
View File

@@ -1,216 +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.
*/
#include <gtest/gtest.h>
#include <yoga/Yoga.h>
#include <yoga/style/Style.h>
#include <cstdint>
#include <type_traits>
#define ACCESSOR_TESTS_1(NAME, X) \
style.NAME() = X; \
ASSERT_EQ(style.NAME(), X);
#define ACCESSOR_TESTS_2(NAME, X, ...) \
ACCESSOR_TESTS_1(NAME, X); \
ACCESSOR_TESTS_1(NAME, __VA_ARGS__);
#define ACCESSOR_TESTS_3(NAME, X, ...) \
ACCESSOR_TESTS_1(NAME, X); \
ACCESSOR_TESTS_2(NAME, __VA_ARGS__);
#define ACCESSOR_TESTS_4(NAME, X, ...) \
ACCESSOR_TESTS_1(NAME, X); \
ACCESSOR_TESTS_3(NAME, __VA_ARGS__);
#define ACCESSOR_TESTS_5(NAME, X, ...) \
ACCESSOR_TESTS_1(NAME, X); \
ACCESSOR_TESTS_4(NAME, __VA_ARGS__)
#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 = Style{}; \
style.NAME()[IDX] = X; \
ASSERT_EQ(style.NAME()[IDX], X); \
auto asArray = decltype(std::declval<const Style&>().NAME()){X}; \
style.NAME() = asArray; \
ASSERT_EQ(static_cast<decltype(asArray)>(style.NAME()), asArray); \
}
#define INDEX_ACCESSOR_TESTS_2(NAME, IDX, X, Y) \
INDEX_ACCESSOR_TESTS_1(NAME, IDX, X) \
INDEX_ACCESSOR_TESTS_1(NAME, IDX, Y)
#define INDEX_ACCESSOR_TESTS_3(NAME, IDX, X, ...) \
INDEX_ACCESSOR_TESTS_1(NAME, IDX, X) \
INDEX_ACCESSOR_TESTS_2(NAME, IDX, __VA_ARGS__)
#define INDEX_ACCESSOR_TESTS_4(NAME, IDX, X, ...) \
INDEX_ACCESSOR_TESTS_1(NAME, IDX, X) \
INDEX_ACCESSOR_TESTS_3(NAME, IDX, __VA_ARGS__)
#define INDEX_ACCESSOR_TESTS_5(NAME, IDX, X, ...) \
INDEX_ACCESSOR_TESTS_1(NAME, IDX, X) \
INDEX_ACCESSOR_TESTS_4(NAME, IDX, __VA_ARGS__)
#define INDEX_ACCESSOR_TESTS_N(a, b, c, d, e, COUNT, ...) \
INDEX_ACCESSOR_TESTS_##COUNT
#define INDEX_ACCESSOR_TESTS(...) \
INDEX_ACCESSOR_TESTS_N(__VA_ARGS__, 5, 4, 3, 2, 1)
// test macro for up to 5 values. If more are needed, extend the macros above.
#define ACCESSOR_TEST(NAME, DEFAULT_VAL, ...) \
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(Style, style_##NAME##_access) { \
ASSERT_EQ(Style{}.NAME()[IDX], DEFAULT_VAL); \
INDEX_ACCESSOR_TESTS(__VA_ARGS__)(NAME, IDX, __VA_ARGS__) \
}
namespace facebook::yoga {
// TODO: MSVC doesn't like the macros
#ifndef _MSC_VER
ACCESSOR_TEST(
direction,
Direction::Inherit,
Direction::LTR,
Direction::RTL,
Direction::Inherit);
ACCESSOR_TEST(
flexDirection,
FlexDirection::Column,
FlexDirection::ColumnReverse,
FlexDirection::RowReverse,
FlexDirection::Row)
ACCESSOR_TEST(
justifyContent,
Justify::FlexStart,
Justify::FlexEnd,
Justify::SpaceAround,
Justify::FlexStart,
Justify::SpaceEvenly)
ACCESSOR_TEST(
alignContent,
Align::FlexStart,
Align::Auto,
Align::FlexStart,
Align::Center,
Align::FlexEnd,
Align::Stretch)
ACCESSOR_TEST(
alignItems,
Align::Stretch,
Align::FlexStart,
Align::FlexEnd,
Align::Baseline,
Align::SpaceBetween,
Align::SpaceAround)
ACCESSOR_TEST(
alignSelf,
Align::Auto,
Align::FlexStart,
Align::Center,
Align::Auto,
Align::FlexEnd,
Align::Stretch)
ACCESSOR_TEST(
positionType,
PositionType::Static,
PositionType::Absolute,
PositionType::Relative)
ACCESSOR_TEST(flexWrap, Wrap::NoWrap, Wrap::Wrap, Wrap::WrapReverse)
ACCESSOR_TEST(overflow, Overflow::Visible, Overflow::Hidden, Overflow::Scroll)
ACCESSOR_TEST(display, Display::Flex, Display::None, Display::Flex)
ACCESSOR_TEST(
flex,
FloatOptional{},
FloatOptional{123.45f},
FloatOptional{-9.87f},
FloatOptional{})
ACCESSOR_TEST(
flexGrow,
FloatOptional{},
FloatOptional{123.45f},
FloatOptional{-9.87f},
FloatOptional{})
ACCESSOR_TEST(
flexShrink,
FloatOptional{},
FloatOptional{123.45f},
FloatOptional{-9.87f},
FloatOptional{})
ACCESSOR_TEST(
flexBasis,
CompactValue::ofAuto(),
CompactValue::ofUndefined(),
CompactValue::ofAuto(),
CompactValue::of<YGUnitPoint>(7777.77f),
CompactValue::of<YGUnitPercent>(-100.0f))
INDEX_ACCESSOR_TEST(
position,
CompactValue::ofUndefined(),
YGEdgeBottom,
CompactValue::ofAuto(),
CompactValue::ofUndefined(),
CompactValue::of<YGUnitPoint>(7777.77f),
CompactValue::of<YGUnitPercent>(-100.0f))
INDEX_ACCESSOR_TEST(
margin,
CompactValue::ofUndefined(),
YGEdgeTop,
CompactValue::ofAuto(),
CompactValue::ofUndefined(),
CompactValue::of<YGUnitPoint>(7777.77f),
CompactValue::of<YGUnitPercent>(-100.0f))
INDEX_ACCESSOR_TEST(
padding,
CompactValue::ofUndefined(),
YGEdgeAll,
CompactValue::of<YGUnitPoint>(7777.77f),
CompactValue::ofUndefined(),
CompactValue::of<YGUnitPercent>(-100.0f))
INDEX_ACCESSOR_TEST(
border,
CompactValue::ofUndefined(),
YGEdgeHorizontal,
CompactValue::of<YGUnitPoint>(-7777.77f),
CompactValue::ofUndefined())
ACCESSOR_TEST(
aspectRatio,
FloatOptional{},
FloatOptional{-123.45f},
FloatOptional{9876.5f},
FloatOptional{0.0f},
FloatOptional{});
#endif
} // namespace facebook::yoga

47
yoga/YGNodeStyle.cpp
View File

@@ -35,19 +35,6 @@ void updateStyle(YGNodeRef node, Ref (Style::*prop)(), T value) {
[prop](Style& s, T x) { (s.*prop)() = x; }); [prop](Style& s, T x) { (s.*prop)() = x; });
} }
template <typename Ref, typename Idx>
void updateIndexedStyleProp(
YGNodeRef node,
Ref (Style::*prop)(),
Idx idx,
CompactValue value) {
updateStyle(
resolveRef(node),
value,
[idx, prop](Style& s, CompactValue x) { return (s.*prop)()[idx] != x; },
[idx, prop](Style& s, CompactValue x) { (s.*prop)()[idx] = x; });
}
template <auto GetterT, auto SetterT, typename IdxT> template <auto GetterT, auto SetterT, typename IdxT>
void updateIndexedStyleProp(YGNodeRef node, IdxT idx, CompactValue value) { void updateIndexedStyleProp(YGNodeRef node, IdxT idx, CompactValue value) {
updateStyle( updateStyle(
@@ -237,53 +224,53 @@ YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) {
void YGNodeStyleSetPosition(YGNodeRef node, YGEdge edge, float points) { void YGNodeStyleSetPosition(YGNodeRef node, YGEdge edge, float points) {
auto value = CompactValue::ofMaybe<YGUnitPoint>(points); auto value = CompactValue::ofMaybe<YGUnitPoint>(points);
updateIndexedStyleProp<MSVC_HINT(position)>( updateIndexedStyleProp<&Style::position, &Style::setPosition>(
node, &Style::position, edge, value); node, edge, value);
} }
void YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge, float percent) { void YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge, float percent) {
auto value = CompactValue::ofMaybe<YGUnitPercent>(percent); auto value = CompactValue::ofMaybe<YGUnitPercent>(percent);
updateIndexedStyleProp<MSVC_HINT(position)>( updateIndexedStyleProp<&Style::position, &Style::setPosition>(
node, &Style::position, edge, value); node, edge, value);
} }
YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) { YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) {
return resolveRef(node)->getStyle().position()[edge]; return resolveRef(node)->getStyle().position(edge);
} }
void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float points) { void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float points) {
auto value = CompactValue::ofMaybe<YGUnitPoint>(points); auto value = CompactValue::ofMaybe<YGUnitPoint>(points);
updateIndexedStyleProp<MSVC_HINT(margin)>(node, &Style::margin, edge, value); updateIndexedStyleProp<&Style::margin, &Style::setMargin>(node, edge, value);
} }
void YGNodeStyleSetMarginPercent(YGNodeRef node, YGEdge edge, float percent) { void YGNodeStyleSetMarginPercent(YGNodeRef node, YGEdge edge, float percent) {
auto value = CompactValue::ofMaybe<YGUnitPercent>(percent); auto value = CompactValue::ofMaybe<YGUnitPercent>(percent);
updateIndexedStyleProp<MSVC_HINT(margin)>(node, &Style::margin, edge, value); updateIndexedStyleProp<&Style::margin, &Style::setMargin>(node, edge, value);
} }
void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge) { void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge) {
updateIndexedStyleProp<MSVC_HINT(margin)>( updateIndexedStyleProp<&Style::margin, &Style::setMargin>(
node, &Style::margin, edge, CompactValue::ofAuto()); node, edge, CompactValue::ofAuto());
} }
YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge) { YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge) {
return resolveRef(node)->getStyle().margin()[edge]; return resolveRef(node)->getStyle().margin(edge);
} }
void YGNodeStyleSetPadding(YGNodeRef node, YGEdge edge, float points) { void YGNodeStyleSetPadding(YGNodeRef node, YGEdge edge, float points) {
auto value = CompactValue::ofMaybe<YGUnitPoint>(points); auto value = CompactValue::ofMaybe<YGUnitPoint>(points);
updateIndexedStyleProp<MSVC_HINT(padding)>( updateIndexedStyleProp<&Style::padding, &Style::setPadding>(
node, &Style::padding, edge, value); node, edge, value);
} }
void YGNodeStyleSetPaddingPercent(YGNodeRef node, YGEdge edge, float percent) { void YGNodeStyleSetPaddingPercent(YGNodeRef node, YGEdge edge, float percent) {
auto value = CompactValue::ofMaybe<YGUnitPercent>(percent); auto value = CompactValue::ofMaybe<YGUnitPercent>(percent);
updateIndexedStyleProp<MSVC_HINT(padding)>( updateIndexedStyleProp<&Style::padding, &Style::setPadding>(
node, &Style::padding, edge, value); node, edge, value);
} }
YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge) { YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge) {
return resolveRef(node)->getStyle().padding()[edge]; return resolveRef(node)->getStyle().padding(edge);
} }
void YGNodeStyleSetBorder( void YGNodeStyleSetBorder(
@@ -291,11 +278,11 @@ void YGNodeStyleSetBorder(
const YGEdge edge, const YGEdge edge,
const float border) { const float border) {
auto value = CompactValue::ofMaybe<YGUnitPoint>(border); auto value = CompactValue::ofMaybe<YGUnitPoint>(border);
updateIndexedStyleProp<MSVC_HINT(border)>(node, &Style::border, edge, value); updateIndexedStyleProp<&Style::border, &Style::setBorder>(node, edge, value);
} }
float YGNodeStyleGetBorder(const YGNodeConstRef node, const YGEdge edge) { float YGNodeStyleGetBorder(const YGNodeConstRef node, const YGEdge edge) {
auto border = resolveRef(node)->getStyle().border()[edge]; auto border = resolveRef(node)->getStyle().border(edge);
if (border.isUndefined() || border.isAuto()) { if (border.isUndefined() || border.isAuto()) {
return YGUndefined; return YGUndefined;
} }

1
yoga/algorithm/FlexDirection.h
View File

@@ -11,6 +11,7 @@
#include <yoga/debug/AssertFatal.h> #include <yoga/debug/AssertFatal.h>
#include <yoga/enums/Dimension.h> #include <yoga/enums/Dimension.h>
#include <yoga/enums/Direction.h>
#include <yoga/enums/FlexDirection.h> #include <yoga/enums/FlexDirection.h>
namespace facebook::yoga { namespace facebook::yoga {

2
yoga/debug/AssertFatal.cpp
View File

@@ -7,8 +7,10 @@
#include <stdexcept> #include <stdexcept>
#include <yoga/config/Config.h>
#include <yoga/debug/AssertFatal.h> #include <yoga/debug/AssertFatal.h>
#include <yoga/debug/Log.h> #include <yoga/debug/Log.h>
#include <yoga/node/Node.h>
namespace facebook::yoga { namespace facebook::yoga {

5
yoga/debug/AssertFatal.h
View File

@@ -8,11 +8,12 @@
#pragma once #pragma once
#include <yoga/Yoga.h> #include <yoga/Yoga.h>
#include <yoga/config/Config.h>
#include <yoga/node/Node.h>
namespace facebook::yoga { namespace facebook::yoga {
class Node;
class Config;
[[noreturn]] void fatalWithMessage(const char* message); [[noreturn]] void fatalWithMessage(const char* message);
void assertFatal(bool condition, const char* message); void assertFatal(bool condition, const char* message);

43
yoga/debug/NodeToString.cpp
View File

@@ -23,12 +23,6 @@ static void indent(std::string& base, uint32_t level) {
} }
} }
static bool areFourValuesEqual(const Style::Edges& four) {
return yoga::inexactEquals(four[0], four[1]) &&
yoga::inexactEquals(four[0], four[2]) &&
yoga::inexactEquals(four[0], four[3]);
}
static void appendFormattedString(std::string& str, const char* fmt, ...) { static void appendFormattedString(std::string& str, const char* fmt, ...) {
va_list args; va_list args;
va_start(args, fmt); va_start(args, fmt);
@@ -86,32 +80,14 @@ static void appendNumberIfNotZero(
} }
} }
static void appendEdges( template <auto Field>
std::string& base, static void
const std::string& key, appendEdges(std::string& base, const std::string& key, const Style& style) {
const Style::Edges& edges) {
if (areFourValuesEqual(edges)) {
auto edgeValue = yoga::Node::computeEdgeValueForColumn(edges, YGEdgeLeft);
appendNumberIfNotUndefined(base, key, edgeValue);
} else {
for (int edge = YGEdgeLeft; edge != YGEdgeAll; ++edge) { for (int edge = YGEdgeLeft; edge != YGEdgeAll; ++edge) {
std::string str = key + "-" + YGEdgeToString(static_cast<YGEdge>(edge)); std::string str = key + "-" + YGEdgeToString(static_cast<YGEdge>(edge));
appendNumberIfNotZero(base, str, edges[static_cast<size_t>(edge)]); appendNumberIfNotZero(base, str, (style.*Field)(static_cast<YGEdge>(edge)));
} }
} }
}
static void appendEdgeIfNotUndefined(
std::string& base,
const std::string& str,
const Style::Edges& edges,
const YGEdge edge) {
// TODO: this doesn't take RTL / YGEdgeStart / YGEdgeEnd into account
auto value = (edge == YGEdgeLeft || edge == YGEdgeRight)
? yoga::Node::computeEdgeValueForRow(edges, edge, edge)
: yoga::Node::computeEdgeValueForColumn(edges, edge);
appendNumberIfNotUndefined(base, str, value);
}
void nodeToString( void nodeToString(
std::string& str, std::string& str,
@@ -173,9 +149,9 @@ void nodeToString(
if (style.display() != yoga::Node{}.getStyle().display()) { if (style.display() != yoga::Node{}.getStyle().display()) {
appendFormattedString(str, "display: %s; ", toString(style.display())); appendFormattedString(str, "display: %s; ", toString(style.display()));
} }
appendEdges(str, "margin", style.margin()); appendEdges<&Style::margin>(str, "margin", style);
appendEdges(str, "padding", style.padding()); appendEdges<&Style::padding>(str, "padding", style);
appendEdges(str, "border", style.border()); appendEdges<&Style::border>(str, "border", style);
if (style.gap(Gutter::All).isDefined()) { if (style.gap(Gutter::All).isDefined()) {
appendNumberIfNotUndefined(str, "gap", style.gap(Gutter::All)); appendNumberIfNotUndefined(str, "gap", style.gap(Gutter::All));
@@ -200,10 +176,7 @@ void nodeToString(
str, "position: %s; ", toString(style.positionType())); str, "position: %s; ", toString(style.positionType()));
} }
appendEdgeIfNotUndefined(str, "left", style.position(), YGEdgeLeft); appendEdges<&Style::position>(str, "position", style);
appendEdgeIfNotUndefined(str, "right", style.position(), YGEdgeRight);
appendEdgeIfNotUndefined(str, "top", style.position(), YGEdgeTop);
appendEdgeIfNotUndefined(str, "bottom", style.position(), YGEdgeBottom);
appendFormattedString(str, "\" "); appendFormattedString(str, "\" ");
if (node->hasMeasureFunc()) { if (node->hasMeasureFunc()) {

137
yoga/node/Node.cpp
View File

@@ -56,30 +56,29 @@ void Node::print() {
} }
} }
CompactValue Node::computeEdgeValueForRow( // TODO: Edge value resolution should be moved to `yoga::Style`
const Style::Edges& edges, template <auto Field>
YGEdge rowEdge, CompactValue Node::computeEdgeValueForRow(YGEdge rowEdge, YGEdge edge) const {
YGEdge edge) { if ((style_.*Field)(rowEdge).isDefined()) {
if (edges[rowEdge].isDefined()) { return (style_.*Field)(rowEdge);
return edges[rowEdge]; } else if ((style_.*Field)(edge).isDefined()) {
} else if (edges[edge].isDefined()) { return (style_.*Field)(edge);
return edges[edge]; } else if ((style_.*Field)(YGEdgeHorizontal).isDefined()) {
} else if (edges[YGEdgeHorizontal].isDefined()) { return (style_.*Field)(YGEdgeHorizontal);
return edges[YGEdgeHorizontal];
} else { } else {
return edges[YGEdgeAll]; return (style_.*Field)(YGEdgeAll);
} }
} }
CompactValue Node::computeEdgeValueForColumn( // TODO: Edge value resolution should be moved to `yoga::Style`
const Style::Edges& edges, template <auto Field>
YGEdge edge) { CompactValue Node::computeEdgeValueForColumn(YGEdge edge) const {
if (edges[edge].isDefined()) { if ((style_.*Field)(edge).isDefined()) {
return edges[edge]; return (style_.*Field)(edge);
} else if (edges[YGEdgeVertical].isDefined()) { } else if ((style_.*Field)(YGEdgeVertical).isDefined()) {
return edges[YGEdgeVertical]; return (style_.*Field)(YGEdgeVertical);
} else { } else {
return edges[YGEdgeAll]; return (style_.*Field)(YGEdgeAll);
} }
} }
@@ -102,8 +101,8 @@ YGEdge Node::getInlineEndEdgeUsingErrata(
bool Node::isFlexStartPositionDefined(FlexDirection axis) const { bool Node::isFlexStartPositionDefined(FlexDirection axis) const {
const YGEdge startEdge = flexStartEdge(axis); const YGEdge startEdge = flexStartEdge(axis);
auto leadingPosition = isRow(axis) auto leadingPosition = isRow(axis)
? computeEdgeValueForRow(style_.position(), YGEdgeStart, startEdge) ? computeEdgeValueForRow<&Style::position>(YGEdgeStart, startEdge)
: computeEdgeValueForColumn(style_.position(), startEdge); : computeEdgeValueForColumn<&Style::position>(startEdge);
return leadingPosition.isDefined(); return leadingPosition.isDefined();
} }
@@ -112,8 +111,8 @@ bool Node::isInlineStartPositionDefined(FlexDirection axis, Direction direction)
const { const {
const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction); const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
auto leadingPosition = isRow(axis) auto leadingPosition = isRow(axis)
? computeEdgeValueForRow(style_.position(), YGEdgeStart, startEdge) ? computeEdgeValueForRow<&Style::position>(YGEdgeStart, startEdge)
: computeEdgeValueForColumn(style_.position(), startEdge); : computeEdgeValueForColumn<&Style::position>(startEdge);
return leadingPosition.isDefined(); return leadingPosition.isDefined();
} }
@@ -121,8 +120,8 @@ bool Node::isInlineStartPositionDefined(FlexDirection axis, Direction direction)
bool Node::isFlexEndPositionDefined(FlexDirection axis) const { bool Node::isFlexEndPositionDefined(FlexDirection axis) const {
const YGEdge endEdge = flexEndEdge(axis); const YGEdge endEdge = flexEndEdge(axis);
auto trailingPosition = isRow(axis) auto trailingPosition = isRow(axis)
? computeEdgeValueForRow(style_.position(), YGEdgeEnd, endEdge) ? computeEdgeValueForRow<&Style::position>(YGEdgeEnd, endEdge)
: computeEdgeValueForColumn(style_.position(), endEdge); : computeEdgeValueForColumn<&Style::position>(endEdge);
return !trailingPosition.isUndefined(); return !trailingPosition.isUndefined();
} }
@@ -131,8 +130,8 @@ bool Node::isInlineEndPositionDefined(FlexDirection axis, Direction direction)
const { const {
const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction); const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
auto trailingPosition = isRow(axis) auto trailingPosition = isRow(axis)
? computeEdgeValueForRow(style_.position(), YGEdgeEnd, endEdge) ? computeEdgeValueForRow<&Style::position>(YGEdgeEnd, endEdge)
: computeEdgeValueForColumn(style_.position(), endEdge); : computeEdgeValueForColumn<&Style::position>(endEdge);
return trailingPosition.isDefined(); return trailingPosition.isDefined();
} }
@@ -140,8 +139,8 @@ bool Node::isInlineEndPositionDefined(FlexDirection axis, Direction direction)
float Node::getFlexStartPosition(FlexDirection axis, float axisSize) const { float Node::getFlexStartPosition(FlexDirection axis, float axisSize) const {
const YGEdge startEdge = flexStartEdge(axis); const YGEdge startEdge = flexStartEdge(axis);
auto leadingPosition = isRow(axis) auto leadingPosition = isRow(axis)
? computeEdgeValueForRow(style_.position(), YGEdgeStart, startEdge) ? computeEdgeValueForRow<&Style::position>(YGEdgeStart, startEdge)
: computeEdgeValueForColumn(style_.position(), startEdge); : computeEdgeValueForColumn<&Style::position>(startEdge);
return resolveValue(leadingPosition, axisSize).unwrapOrDefault(0.0f); return resolveValue(leadingPosition, axisSize).unwrapOrDefault(0.0f);
} }
@@ -152,8 +151,8 @@ float Node::getInlineStartPosition(
float axisSize) const { float axisSize) const {
const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction); const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
auto leadingPosition = isRow(axis) auto leadingPosition = isRow(axis)
? computeEdgeValueForRow(style_.position(), YGEdgeStart, startEdge) ? computeEdgeValueForRow<&Style::position>(YGEdgeStart, startEdge)
: computeEdgeValueForColumn(style_.position(), startEdge); : computeEdgeValueForColumn<&Style::position>(startEdge);
return resolveValue(leadingPosition, axisSize).unwrapOrDefault(0.0f); return resolveValue(leadingPosition, axisSize).unwrapOrDefault(0.0f);
} }
@@ -161,8 +160,8 @@ float Node::getInlineStartPosition(
float Node::getFlexEndPosition(FlexDirection axis, float axisSize) const { float Node::getFlexEndPosition(FlexDirection axis, float axisSize) const {
const YGEdge endEdge = flexEndEdge(axis); const YGEdge endEdge = flexEndEdge(axis);
auto trailingPosition = isRow(axis) auto trailingPosition = isRow(axis)
? computeEdgeValueForRow(style_.position(), YGEdgeEnd, endEdge) ? computeEdgeValueForRow<&Style::position>(YGEdgeEnd, endEdge)
: computeEdgeValueForColumn(style_.position(), endEdge); : computeEdgeValueForColumn<&Style::position>(endEdge);
return resolveValue(trailingPosition, axisSize).unwrapOrDefault(0.0f); return resolveValue(trailingPosition, axisSize).unwrapOrDefault(0.0f);
} }
@@ -173,8 +172,8 @@ float Node::getInlineEndPosition(
float axisSize) const { float axisSize) const {
const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction); const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
auto trailingPosition = isRow(axis) auto trailingPosition = isRow(axis)
? computeEdgeValueForRow(style_.position(), YGEdgeEnd, endEdge) ? computeEdgeValueForRow<&Style::position>(YGEdgeEnd, endEdge)
: computeEdgeValueForColumn(style_.position(), endEdge); : computeEdgeValueForColumn<&Style::position>(endEdge);
return resolveValue(trailingPosition, axisSize).unwrapOrDefault(0.0f); return resolveValue(trailingPosition, axisSize).unwrapOrDefault(0.0f);
} }
@@ -182,8 +181,8 @@ float Node::getInlineEndPosition(
float Node::getFlexStartMargin(FlexDirection axis, float widthSize) const { float Node::getFlexStartMargin(FlexDirection axis, float widthSize) const {
const YGEdge startEdge = flexStartEdge(axis); const YGEdge startEdge = flexStartEdge(axis);
auto leadingMargin = isRow(axis) auto leadingMargin = isRow(axis)
? computeEdgeValueForRow(style_.margin(), YGEdgeStart, startEdge) ? computeEdgeValueForRow<&Style::margin>(YGEdgeStart, startEdge)
: computeEdgeValueForColumn(style_.margin(), startEdge); : computeEdgeValueForColumn<&Style::margin>(startEdge);
return resolveValue(leadingMargin, widthSize).unwrapOrDefault(0.0f); return resolveValue(leadingMargin, widthSize).unwrapOrDefault(0.0f);
} }
@@ -194,8 +193,8 @@ float Node::getInlineStartMargin(
float widthSize) const { float widthSize) const {
const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction); const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
auto leadingMargin = isRow(axis) auto leadingMargin = isRow(axis)
? computeEdgeValueForRow(style_.margin(), YGEdgeStart, startEdge) ? computeEdgeValueForRow<&Style::margin>(YGEdgeStart, startEdge)
: computeEdgeValueForColumn(style_.margin(), startEdge); : computeEdgeValueForColumn<&Style::margin>(startEdge);
return resolveValue(leadingMargin, widthSize).unwrapOrDefault(0.0f); return resolveValue(leadingMargin, widthSize).unwrapOrDefault(0.0f);
} }
@@ -203,8 +202,8 @@ float Node::getInlineStartMargin(
float Node::getFlexEndMargin(FlexDirection axis, float widthSize) const { float Node::getFlexEndMargin(FlexDirection axis, float widthSize) const {
const YGEdge endEdge = flexEndEdge(axis); const YGEdge endEdge = flexEndEdge(axis);
auto trailingMargin = isRow(axis) auto trailingMargin = isRow(axis)
? computeEdgeValueForRow(style_.margin(), YGEdgeEnd, endEdge) ? computeEdgeValueForRow<&Style::margin>(YGEdgeEnd, endEdge)
: computeEdgeValueForColumn(style_.margin(), endEdge); : computeEdgeValueForColumn<&Style::margin>(endEdge);
return resolveValue(trailingMargin, widthSize).unwrapOrDefault(0.0f); return resolveValue(trailingMargin, widthSize).unwrapOrDefault(0.0f);
} }
@@ -215,8 +214,8 @@ float Node::getInlineEndMargin(
float widthSize) const { float widthSize) const {
const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction); const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
auto trailingMargin = isRow(axis) auto trailingMargin = isRow(axis)
? computeEdgeValueForRow(style_.margin(), YGEdgeEnd, endEdge) ? computeEdgeValueForRow<&Style::margin>(YGEdgeEnd, endEdge)
: computeEdgeValueForColumn(style_.margin(), endEdge); : computeEdgeValueForColumn<&Style::margin>(endEdge);
return resolveValue(trailingMargin, widthSize).unwrapOrDefault(0.0f); return resolveValue(trailingMargin, widthSize).unwrapOrDefault(0.0f);
} }
@@ -225,8 +224,8 @@ float Node::getInlineStartBorder(FlexDirection axis, Direction direction)
const { const {
const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction); const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
YGValue leadingBorder = isRow(axis) YGValue leadingBorder = isRow(axis)
? computeEdgeValueForRow(style_.border(), YGEdgeStart, startEdge) ? computeEdgeValueForRow<&Style::border>(YGEdgeStart, startEdge)
: computeEdgeValueForColumn(style_.border(), startEdge); : computeEdgeValueForColumn<&Style::border>(startEdge);
return maxOrDefined(leadingBorder.value, 0.0f); return maxOrDefined(leadingBorder.value, 0.0f);
} }
@@ -235,9 +234,9 @@ float Node::getFlexStartBorder(FlexDirection axis, Direction direction) const {
const YGEdge leadRelativeFlexItemEdge = const YGEdge leadRelativeFlexItemEdge =
flexStartRelativeEdge(axis, direction); flexStartRelativeEdge(axis, direction);
YGValue leadingBorder = isRow(axis) YGValue leadingBorder = isRow(axis)
? computeEdgeValueForRow( ? computeEdgeValueForRow<&Style::border>(
style_.border(), leadRelativeFlexItemEdge, flexStartEdge(axis)) leadRelativeFlexItemEdge, flexStartEdge(axis))
: computeEdgeValueForColumn(style_.border(), flexStartEdge(axis)); : computeEdgeValueForColumn<&Style::border>(flexStartEdge(axis));
return maxOrDefined(leadingBorder.value, 0.0f); return maxOrDefined(leadingBorder.value, 0.0f);
} }
@@ -245,8 +244,8 @@ float Node::getFlexStartBorder(FlexDirection axis, Direction direction) const {
float Node::getInlineEndBorder(FlexDirection axis, Direction direction) const { float Node::getInlineEndBorder(FlexDirection axis, Direction direction) const {
const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction); const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
YGValue trailingBorder = isRow(axis) YGValue trailingBorder = isRow(axis)
? computeEdgeValueForRow(style_.border(), YGEdgeEnd, endEdge) ? computeEdgeValueForRow<&Style::border>(YGEdgeEnd, endEdge)
: computeEdgeValueForColumn(style_.border(), endEdge); : computeEdgeValueForColumn<&Style::border>(endEdge);
return maxOrDefined(trailingBorder.value, 0.0f); return maxOrDefined(trailingBorder.value, 0.0f);
} }
@@ -254,9 +253,9 @@ float Node::getInlineEndBorder(FlexDirection axis, Direction direction) const {
float Node::getFlexEndBorder(FlexDirection axis, Direction direction) const { float Node::getFlexEndBorder(FlexDirection axis, Direction direction) const {
const YGEdge trailRelativeFlexItemEdge = flexEndRelativeEdge(axis, direction); const YGEdge trailRelativeFlexItemEdge = flexEndRelativeEdge(axis, direction);
YGValue trailingBorder = isRow(axis) YGValue trailingBorder = isRow(axis)
? computeEdgeValueForRow( ? computeEdgeValueForRow<&Style::border>(
style_.border(), trailRelativeFlexItemEdge, flexEndEdge(axis)) trailRelativeFlexItemEdge, flexEndEdge(axis))
: computeEdgeValueForColumn(style_.border(), flexEndEdge(axis)); : computeEdgeValueForColumn<&Style::border>(flexEndEdge(axis));
return maxOrDefined(trailingBorder.value, 0.0f); return maxOrDefined(trailingBorder.value, 0.0f);
} }
@@ -267,8 +266,8 @@ float Node::getInlineStartPadding(
float widthSize) const { float widthSize) const {
const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction); const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
auto leadingPadding = isRow(axis) auto leadingPadding = isRow(axis)
? computeEdgeValueForRow(style_.padding(), YGEdgeStart, startEdge) ? computeEdgeValueForRow<&Style::padding>(YGEdgeStart, startEdge)
: computeEdgeValueForColumn(style_.padding(), startEdge); : computeEdgeValueForColumn<&Style::padding>(startEdge);
return maxOrDefined(resolveValue(leadingPadding, widthSize).unwrap(), 0.0f); return maxOrDefined(resolveValue(leadingPadding, widthSize).unwrap(), 0.0f);
} }
@@ -280,9 +279,9 @@ float Node::getFlexStartPadding(
const YGEdge leadRelativeFlexItemEdge = const YGEdge leadRelativeFlexItemEdge =
flexStartRelativeEdge(axis, direction); flexStartRelativeEdge(axis, direction);
auto leadingPadding = isRow(axis) auto leadingPadding = isRow(axis)
? computeEdgeValueForRow( ? computeEdgeValueForRow<&Style::padding>(
style_.padding(), leadRelativeFlexItemEdge, flexStartEdge(axis)) leadRelativeFlexItemEdge, flexStartEdge(axis))
: computeEdgeValueForColumn(style_.padding(), flexStartEdge(axis)); : computeEdgeValueForColumn<&Style::padding>(flexStartEdge(axis));
return maxOrDefined(resolveValue(leadingPadding, widthSize).unwrap(), 0.0f); return maxOrDefined(resolveValue(leadingPadding, widthSize).unwrap(), 0.0f);
} }
@@ -293,8 +292,8 @@ float Node::getInlineEndPadding(
float widthSize) const { float widthSize) const {
const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction); const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
auto trailingPadding = isRow(axis) auto trailingPadding = isRow(axis)
? computeEdgeValueForRow(style_.padding(), YGEdgeEnd, endEdge) ? computeEdgeValueForRow<&Style::padding>(YGEdgeEnd, endEdge)
: computeEdgeValueForColumn(style_.padding(), endEdge); : computeEdgeValueForColumn<&Style::padding>(endEdge);
return maxOrDefined(resolveValue(trailingPadding, widthSize).unwrap(), 0.0f); return maxOrDefined(resolveValue(trailingPadding, widthSize).unwrap(), 0.0f);
} }
@@ -305,9 +304,9 @@ float Node::getFlexEndPadding(
float widthSize) const { float widthSize) const {
const YGEdge trailRelativeFlexItemEdge = flexEndRelativeEdge(axis, direction); const YGEdge trailRelativeFlexItemEdge = flexEndRelativeEdge(axis, direction);
auto trailingPadding = isRow(axis) auto trailingPadding = isRow(axis)
? computeEdgeValueForRow( ? computeEdgeValueForRow<&Style::padding>(
style_.padding(), trailRelativeFlexItemEdge, flexEndEdge(axis)) trailRelativeFlexItemEdge, flexEndEdge(axis))
: computeEdgeValueForColumn(style_.padding(), flexEndEdge(axis)); : computeEdgeValueForColumn<&Style::padding>(flexEndEdge(axis));
return maxOrDefined(resolveValue(trailingPadding, widthSize).unwrap(), 0.0f); return maxOrDefined(resolveValue(trailingPadding, widthSize).unwrap(), 0.0f);
} }
@@ -565,18 +564,18 @@ void Node::setPosition(
} }
YGValue Node::getFlexStartMarginValue(FlexDirection axis) const { YGValue Node::getFlexStartMarginValue(FlexDirection axis) const {
if (isRow(axis) && style_.margin()[YGEdgeStart].isDefined()) { if (isRow(axis) && style_.margin(YGEdgeStart).isDefined()) {
return style_.margin()[YGEdgeStart]; return style_.margin(YGEdgeStart);
} else { } else {
return style_.margin()[flexStartEdge(axis)]; return style_.margin(flexStartEdge(axis));
} }
} }
YGValue Node::marginTrailingValue(FlexDirection axis) const { YGValue Node::marginTrailingValue(FlexDirection axis) const {
if (isRow(axis) && style_.margin()[YGEdgeEnd].isDefined()) { if (isRow(axis) && style_.margin(YGEdgeEnd).isDefined()) {
return style_.margin()[YGEdgeEnd]; return style_.margin(YGEdgeEnd);
} else { } else {
return style_.margin()[flexEndEdge(axis)]; return style_.margin(flexEndEdge(axis));
} }
} }

15
yoga/node/Node.h
View File

@@ -65,6 +65,12 @@ class YG_EXPORT Node : public ::YGNode {
style_.alignContent() = Align::Stretch; style_.alignContent() = Align::Stretch;
} }
template <auto Field>
CompactValue computeEdgeValueForColumn(YGEdge edge) const;
template <auto Field>
CompactValue computeEdgeValueForRow(YGEdge rowEdge, YGEdge edge) const;
// DANGER DANGER DANGER! // DANGER DANGER DANGER!
// If the node assigned to has children, we'd either have to deallocate // If the node assigned to has children, we'd either have to deallocate
// them (potentially incorrect) or ignore them (danger of leaks). Only ever // them (potentially incorrect) or ignore them (danger of leaks). Only ever
@@ -189,15 +195,6 @@ class YG_EXPORT Node : public ::YGNode {
return resolvedDimensions_[static_cast<size_t>(dimension)]; return resolvedDimensions_[static_cast<size_t>(dimension)];
} }
static CompactValue computeEdgeValueForColumn(
const Style::Edges& edges,
YGEdge edge);
static CompactValue computeEdgeValueForRow(
const Style::Edges& edges,
YGEdge rowEdge,
YGEdge edge);
// Methods related to positions, margin, padding and border // Methods related to positions, margin, padding and border
bool isFlexStartPositionDefined(FlexDirection axis) const; bool isFlexStartPositionDefined(FlexDirection axis) const;
bool isInlineStartPositionDefined(FlexDirection axis, Direction direction) bool isInlineStartPositionDefined(FlexDirection axis, Direction direction)

70
yoga/style/Style.h
View File

@@ -34,11 +34,11 @@ class YG_EXPORT Style {
template <typename Enum> template <typename Enum>
using Values = std::array<CompactValue, ordinalCount<Enum>()>; using Values = std::array<CompactValue, ordinalCount<Enum>()>;
public:
using Dimensions = Values<Dimension>; using Dimensions = Values<Dimension>;
using Edges = Values<YGEdge>; using Edges = Values<YGEdge>;
using Gutters = Values<Gutter>; using Gutters = Values<Gutter>;
public:
static constexpr float DefaultFlexGrow = 0.0f; static constexpr float DefaultFlexGrow = 0.0f;
static constexpr float DefaultFlexShrink = 0.0f; static constexpr float DefaultFlexShrink = 0.0f;
static constexpr float WebDefaultFlexShrink = 1.0f; static constexpr float WebDefaultFlexShrink = 1.0f;
@@ -68,39 +68,6 @@ class YG_EXPORT Style {
} }
}; };
template <typename Idx, Values<Idx> Style::*Prop>
struct IdxRef {
struct Ref {
Style& style;
Idx idx;
operator CompactValue() const {
return (style.*Prop)[idx];
}
operator YGValue() const {
return (style.*Prop)[idx];
}
Ref& operator=(CompactValue value) {
(style.*Prop)[idx] = value;
return *this;
}
};
Style& style;
IdxRef<Idx, Prop>& operator=(const Values<Idx>& values) {
style.*Prop = values;
return *this;
}
operator const Values<Idx>&() const {
return style.*Prop;
}
Ref operator[](Idx idx) {
return {style, idx};
}
CompactValue operator[](Idx idx) const {
return (style.*Prop)[idx];
}
};
Style() { Style() {
alignContent() = Align::FlexStart; alignContent() = Align::FlexStart;
alignItems() = Align::Stretch; alignItems() = Align::Stretch;
@@ -146,9 +113,6 @@ class YG_EXPORT Style {
FloatOptional aspectRatio_ = {}; FloatOptional aspectRatio_ = {};
public: public:
// for library users needing a type
using ValueRepr = std::remove_reference<decltype(margin_[0])>::type;
Direction direction() const { Direction direction() const {
return getEnumData<Direction>(flags, directionOffset); return getEnumData<Direction>(flags, directionOffset);
} }
@@ -247,32 +211,32 @@ class YG_EXPORT Style {
return {*this}; return {*this};
} }
const Edges& margin() const { CompactValue margin(YGEdge edge) const {
return margin_; return margin_[edge];
} }
IdxRef<YGEdge, &Style::margin_> margin() { void setMargin(YGEdge edge, CompactValue value) {
return {*this}; margin_[edge] = value;
} }
const Edges& position() const { CompactValue position(YGEdge edge) const {
return position_; return position_[edge];
} }
IdxRef<YGEdge, &Style::position_> position() { void setPosition(YGEdge edge, CompactValue value) {
return {*this}; position_[edge] = value;
} }
const Edges& padding() const { CompactValue padding(YGEdge edge) const {
return padding_; return padding_[edge];
} }
IdxRef<YGEdge, &Style::padding_> padding() { void setPadding(YGEdge edge, CompactValue value) {
return {*this}; padding_[edge] = value;
} }
const Edges& border() const { CompactValue border(YGEdge edge) const {
return border_; return border_[edge];
} }
IdxRef<YGEdge, &Style::border_> border() { void setBorder(YGEdge edge, CompactValue value) {
return {*this}; border_[edge] = value;
} }
CompactValue gap(Gutter gutter) const { CompactValue gap(Gutter gutter) const {