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

YGEdge -> yoga::Edge (#1461)

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

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

Converts usages of `YGEdge` within internal APIs to `yoga::Edge` scoped enum.

With the exception of YGUnit which is in its own state of transition, this is the last public yoga enum to need to be moved to scoped enum form for usages internal to the Yoga public API.

Changelog: [internal]

Reviewed By: rshest

Differential Revision: D51152779

fbshipit-source-id: 06554f67bfd7709cbc24fdd9a5474e897e9e95d8
This commit is contained in:
Nick Gerleman
2023-11-25 20:41:22 -08:00
committed by Facebook GitHub Bot
parent a121483e81
commit 325ccea068
12 changed files with 243 additions and 211 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
yoga/node/Node.cpp
View File

@@ -58,31 +58,31 @@ void Node::print() {
// TODO: Edge value resolution should be moved to `yoga::Style`
template <auto Field>
Style::Length Node::computeEdgeValueForRow(YGEdge rowEdge, YGEdge edge) const {
Style::Length Node::computeEdgeValueForRow(Edge rowEdge, Edge edge) const {
if ((style_.*Field)(rowEdge).isDefined()) {
return (style_.*Field)(rowEdge);
} else if ((style_.*Field)(edge).isDefined()) {
return (style_.*Field)(edge);
} else if ((style_.*Field)(YGEdgeHorizontal).isDefined()) {
return (style_.*Field)(YGEdgeHorizontal);
} else if ((style_.*Field)(Edge::Horizontal).isDefined()) {
return (style_.*Field)(Edge::Horizontal);
} else {
return (style_.*Field)(YGEdgeAll);
return (style_.*Field)(Edge::All);
}
}
// TODO: Edge value resolution should be moved to `yoga::Style`
template <auto Field>
Style::Length Node::computeEdgeValueForColumn(YGEdge edge) const {
Style::Length Node::computeEdgeValueForColumn(Edge edge) const {
if ((style_.*Field)(edge).isDefined()) {
return (style_.*Field)(edge);
} else if ((style_.*Field)(YGEdgeVertical).isDefined()) {
return (style_.*Field)(YGEdgeVertical);
} else if ((style_.*Field)(Edge::Vertical).isDefined()) {
return (style_.*Field)(Edge::Vertical);
} else {
return (style_.*Field)(YGEdgeAll);
return (style_.*Field)(Edge::All);
}
}
YGEdge Node::getInlineStartEdgeUsingErrata(
Edge Node::getInlineStartEdgeUsingErrata(
FlexDirection flexDirection,
Direction direction) const {
return hasErrata(Errata::StartingEndingEdgeFromFlexDirection)
@@ -90,7 +90,7 @@ YGEdge Node::getInlineStartEdgeUsingErrata(
: inlineStartEdge(flexDirection, direction);
}
YGEdge Node::getInlineEndEdgeUsingErrata(
Edge Node::getInlineEndEdgeUsingErrata(
FlexDirection flexDirection,
Direction direction) const {
return hasErrata(Errata::StartingEndingEdgeFromFlexDirection)
@@ -99,9 +99,9 @@ YGEdge Node::getInlineEndEdgeUsingErrata(
}
bool Node::isFlexStartPositionDefined(FlexDirection axis) const {
const YGEdge startEdge = flexStartEdge(axis);
const Edge startEdge = flexStartEdge(axis);
auto leadingPosition = isRow(axis)
? computeEdgeValueForRow<&Style::position>(YGEdgeStart, startEdge)
? computeEdgeValueForRow<&Style::position>(Edge::Start, startEdge)
: computeEdgeValueForColumn<&Style::position>(startEdge);
return leadingPosition.isDefined();
@@ -109,18 +109,18 @@ bool Node::isFlexStartPositionDefined(FlexDirection axis) const {
bool Node::isInlineStartPositionDefined(FlexDirection axis, Direction direction)
const {
const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
const Edge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
auto leadingPosition = isRow(axis)
? computeEdgeValueForRow<&Style::position>(YGEdgeStart, startEdge)
? computeEdgeValueForRow<&Style::position>(Edge::Start, startEdge)
: computeEdgeValueForColumn<&Style::position>(startEdge);
return leadingPosition.isDefined();
}
bool Node::isFlexEndPositionDefined(FlexDirection axis) const {
const YGEdge endEdge = flexEndEdge(axis);
const Edge endEdge = flexEndEdge(axis);
auto trailingPosition = isRow(axis)
? computeEdgeValueForRow<&Style::position>(YGEdgeEnd, endEdge)
? computeEdgeValueForRow<&Style::position>(Edge::End, endEdge)
: computeEdgeValueForColumn<&Style::position>(endEdge);
return !trailingPosition.isUndefined();
@@ -128,18 +128,18 @@ bool Node::isFlexEndPositionDefined(FlexDirection axis) const {
bool Node::isInlineEndPositionDefined(FlexDirection axis, Direction direction)
const {
const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
const Edge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
auto trailingPosition = isRow(axis)
? computeEdgeValueForRow<&Style::position>(YGEdgeEnd, endEdge)
? computeEdgeValueForRow<&Style::position>(Edge::End, endEdge)
: computeEdgeValueForColumn<&Style::position>(endEdge);
return trailingPosition.isDefined();
}
float Node::getFlexStartPosition(FlexDirection axis, float axisSize) const {
const YGEdge startEdge = flexStartEdge(axis);
const Edge startEdge = flexStartEdge(axis);
auto leadingPosition = isRow(axis)
? computeEdgeValueForRow<&Style::position>(YGEdgeStart, startEdge)
? computeEdgeValueForRow<&Style::position>(Edge::Start, startEdge)
: computeEdgeValueForColumn<&Style::position>(startEdge);
return resolveValue(leadingPosition, axisSize).unwrapOrDefault(0.0f);
@@ -149,18 +149,18 @@ float Node::getInlineStartPosition(
FlexDirection axis,
Direction direction,
float axisSize) const {
const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
const Edge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
auto leadingPosition = isRow(axis)
? computeEdgeValueForRow<&Style::position>(YGEdgeStart, startEdge)
? computeEdgeValueForRow<&Style::position>(Edge::Start, startEdge)
: computeEdgeValueForColumn<&Style::position>(startEdge);
return resolveValue(leadingPosition, axisSize).unwrapOrDefault(0.0f);
}
float Node::getFlexEndPosition(FlexDirection axis, float axisSize) const {
const YGEdge endEdge = flexEndEdge(axis);
const Edge endEdge = flexEndEdge(axis);
auto trailingPosition = isRow(axis)
? computeEdgeValueForRow<&Style::position>(YGEdgeEnd, endEdge)
? computeEdgeValueForRow<&Style::position>(Edge::End, endEdge)
: computeEdgeValueForColumn<&Style::position>(endEdge);
return resolveValue(trailingPosition, axisSize).unwrapOrDefault(0.0f);
@@ -170,18 +170,18 @@ float Node::getInlineEndPosition(
FlexDirection axis,
Direction direction,
float axisSize) const {
const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
const Edge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
auto trailingPosition = isRow(axis)
? computeEdgeValueForRow<&Style::position>(YGEdgeEnd, endEdge)
? computeEdgeValueForRow<&Style::position>(Edge::End, endEdge)
: computeEdgeValueForColumn<&Style::position>(endEdge);
return resolveValue(trailingPosition, axisSize).unwrapOrDefault(0.0f);
}
float Node::getFlexStartMargin(FlexDirection axis, float widthSize) const {
const YGEdge startEdge = flexStartEdge(axis);
const Edge startEdge = flexStartEdge(axis);
auto leadingMargin = isRow(axis)
? computeEdgeValueForRow<&Style::margin>(YGEdgeStart, startEdge)
? computeEdgeValueForRow<&Style::margin>(Edge::Start, startEdge)
: computeEdgeValueForColumn<&Style::margin>(startEdge);
return resolveValue(leadingMargin, widthSize).unwrapOrDefault(0.0f);
@@ -191,18 +191,18 @@ float Node::getInlineStartMargin(
FlexDirection axis,
Direction direction,
float widthSize) const {
const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
const Edge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
auto leadingMargin = isRow(axis)
? computeEdgeValueForRow<&Style::margin>(YGEdgeStart, startEdge)
? computeEdgeValueForRow<&Style::margin>(Edge::Start, startEdge)
: computeEdgeValueForColumn<&Style::margin>(startEdge);
return resolveValue(leadingMargin, widthSize).unwrapOrDefault(0.0f);
}
float Node::getFlexEndMargin(FlexDirection axis, float widthSize) const {
const YGEdge endEdge = flexEndEdge(axis);
const Edge endEdge = flexEndEdge(axis);
auto trailingMargin = isRow(axis)
? computeEdgeValueForRow<&Style::margin>(YGEdgeEnd, endEdge)
? computeEdgeValueForRow<&Style::margin>(Edge::End, endEdge)
: computeEdgeValueForColumn<&Style::margin>(endEdge);
return resolveValue(trailingMargin, widthSize).unwrapOrDefault(0.0f);
@@ -212,9 +212,9 @@ float Node::getInlineEndMargin(
FlexDirection axis,
Direction direction,
float widthSize) const {
const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
const Edge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
auto trailingMargin = isRow(axis)
? computeEdgeValueForRow<&Style::margin>(YGEdgeEnd, endEdge)
? computeEdgeValueForRow<&Style::margin>(Edge::End, endEdge)
: computeEdgeValueForColumn<&Style::margin>(endEdge);
return resolveValue(trailingMargin, widthSize).unwrapOrDefault(0.0f);
@@ -222,17 +222,16 @@ float Node::getInlineEndMargin(
float Node::getInlineStartBorder(FlexDirection axis, Direction direction)
const {
const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
const Edge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
YGValue leadingBorder = isRow(axis)
? computeEdgeValueForRow<&Style::border>(YGEdgeStart, startEdge)
? computeEdgeValueForRow<&Style::border>(Edge::Start, startEdge)
: computeEdgeValueForColumn<&Style::border>(startEdge);
return maxOrDefined(leadingBorder.value, 0.0f);
}
float Node::getFlexStartBorder(FlexDirection axis, Direction direction) const {
const YGEdge leadRelativeFlexItemEdge =
flexStartRelativeEdge(axis, direction);
const Edge leadRelativeFlexItemEdge = flexStartRelativeEdge(axis, direction);
YGValue leadingBorder = isRow(axis)
? computeEdgeValueForRow<&Style::border>(
leadRelativeFlexItemEdge, flexStartEdge(axis))
@@ -242,16 +241,16 @@ float Node::getFlexStartBorder(FlexDirection axis, Direction direction) const {
}
float Node::getInlineEndBorder(FlexDirection axis, Direction direction) const {
const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
const Edge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
YGValue trailingBorder = isRow(axis)
? computeEdgeValueForRow<&Style::border>(YGEdgeEnd, endEdge)
? computeEdgeValueForRow<&Style::border>(Edge::End, endEdge)
: computeEdgeValueForColumn<&Style::border>(endEdge);
return maxOrDefined(trailingBorder.value, 0.0f);
}
float Node::getFlexEndBorder(FlexDirection axis, Direction direction) const {
const YGEdge trailRelativeFlexItemEdge = flexEndRelativeEdge(axis, direction);
const Edge trailRelativeFlexItemEdge = flexEndRelativeEdge(axis, direction);
YGValue trailingBorder = isRow(axis)
? computeEdgeValueForRow<&Style::border>(
trailRelativeFlexItemEdge, flexEndEdge(axis))
@@ -264,9 +263,9 @@ float Node::getInlineStartPadding(
FlexDirection axis,
Direction direction,
float widthSize) const {
const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
const Edge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
auto leadingPadding = isRow(axis)
? computeEdgeValueForRow<&Style::padding>(YGEdgeStart, startEdge)
? computeEdgeValueForRow<&Style::padding>(Edge::Start, startEdge)
: computeEdgeValueForColumn<&Style::padding>(startEdge);
return maxOrDefined(resolveValue(leadingPadding, widthSize).unwrap(), 0.0f);
@@ -276,8 +275,7 @@ float Node::getFlexStartPadding(
FlexDirection axis,
Direction direction,
float widthSize) const {
const YGEdge leadRelativeFlexItemEdge =
flexStartRelativeEdge(axis, direction);
const Edge leadRelativeFlexItemEdge = flexStartRelativeEdge(axis, direction);
auto leadingPadding = isRow(axis)
? computeEdgeValueForRow<&Style::padding>(
leadRelativeFlexItemEdge, flexStartEdge(axis))
@@ -290,9 +288,9 @@ float Node::getInlineEndPadding(
FlexDirection axis,
Direction direction,
float widthSize) const {
const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
const Edge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
auto trailingPadding = isRow(axis)
? computeEdgeValueForRow<&Style::padding>(YGEdgeEnd, endEdge)
? computeEdgeValueForRow<&Style::padding>(Edge::End, endEdge)
: computeEdgeValueForColumn<&Style::padding>(endEdge);
return maxOrDefined(resolveValue(trailingPadding, widthSize).unwrap(), 0.0f);
@@ -302,7 +300,7 @@ float Node::getFlexEndPadding(
FlexDirection axis,
Direction direction,
float widthSize) const {
const YGEdge trailRelativeFlexItemEdge = flexEndRelativeEdge(axis, direction);
const Edge trailRelativeFlexItemEdge = flexEndRelativeEdge(axis, direction);
auto trailingPadding = isRow(axis)
? computeEdgeValueForRow<&Style::padding>(
trailRelativeFlexItemEdge, flexEndEdge(axis))
@@ -446,25 +444,16 @@ void Node::setLayoutDirection(Direction direction) {
layout_.setDirection(direction);
}
void Node::setLayoutMargin(float margin, YGEdge edge) {
assertFatal(
edge < static_cast<int>(layout_.margin.size()),
"Edge must be top/left/bottom/right");
layout_.margin[edge] = margin;
void Node::setLayoutMargin(float margin, Edge edge) {
layout_.setMargin(edge, margin);
}
void Node::setLayoutBorder(float border, YGEdge edge) {
assertFatal(
edge < static_cast<int>(layout_.border.size()),
"Edge must be top/left/bottom/right");
layout_.border[edge] = border;
void Node::setLayoutBorder(float border, Edge edge) {
layout_.setBorder(edge, border);
}
void Node::setLayoutPadding(float padding, YGEdge edge) {
assertFatal(
edge < static_cast<int>(layout_.padding.size()),
"Edge must be top/left/bottom/right");
layout_.padding[edge] = padding;
void Node::setLayoutPadding(float padding, Edge edge) {
layout_.setPadding(edge, padding);
}
void Node::setLayoutLastOwnerDirection(Direction direction) {
@@ -475,11 +464,8 @@ void Node::setLayoutComputedFlexBasis(const FloatOptional computedFlexBasis) {
layout_.computedFlexBasis = computedFlexBasis;
}
void Node::setLayoutPosition(float position, YGEdge edge) {
assertFatal(
edge < static_cast<int>(layout_.position.size()),
"Edge must be top/left/bottom/right");
layout_.position[edge] = position;
void Node::setLayoutPosition(float position, Edge edge) {
layout_.setPosition(edge, position);
}
void Node::setLayoutComputedFlexBasisGeneration(
@@ -536,13 +522,13 @@ void Node::setPosition(
const float relativePositionCross =
relativePosition(crossAxis, directionRespectingRoot, crossSize);
const YGEdge mainAxisLeadingEdge =
const Edge mainAxisLeadingEdge =
getInlineStartEdgeUsingErrata(mainAxis, direction);
const YGEdge mainAxisTrailingEdge =
const Edge mainAxisTrailingEdge =
getInlineEndEdgeUsingErrata(mainAxis, direction);
const YGEdge crossAxisLeadingEdge =
const Edge crossAxisLeadingEdge =
getInlineStartEdgeUsingErrata(crossAxis, direction);
const YGEdge crossAxisTrailingEdge =
const Edge crossAxisTrailingEdge =
getInlineEndEdgeUsingErrata(crossAxis, direction);
setLayoutPosition(
@@ -564,16 +550,16 @@ void Node::setPosition(
}
YGValue Node::getFlexStartMarginValue(FlexDirection axis) const {
if (isRow(axis) && style_.margin(YGEdgeStart).isDefined()) {
return style_.margin(YGEdgeStart);
if (isRow(axis) && style_.margin(Edge::Start).isDefined()) {
return style_.margin(Edge::Start);
} else {
return style_.margin(flexStartEdge(axis));
}
}
YGValue Node::marginTrailingValue(FlexDirection axis) const {
if (isRow(axis) && style_.margin(YGEdgeEnd).isDefined()) {
return style_.margin(YGEdgeEnd);
if (isRow(axis) && style_.margin(Edge::End).isDefined()) {
return style_.margin(Edge::End);
} else {
return style_.margin(flexEndEdge(axis));
}