Skip to content

Commit 75e783d

Browse files
woehrl01facebook-github-bot
woehrl01
authored and
facebook-github-bot
committed
Align resolve function names to have similiar namings
Summary: We have some resolve functions with ```YG**Resolve``` and others named ```YGResolve**```. This changes both to be named like the later one, as I think this is the grammatically better readable one. Closes react/yoga#471 Differential Revision: D4688997 Pulled By: emilsjolander fbshipit-source-id: 38b5f84d4d39ed3effedf08188085b9efd96b4ce
1 parent f0394ce commit 75e783d

1 file changed

Lines changed: 51 additions & 51 deletions

File tree

‎ReactCommon/yoga/yoga/Yoga.c‎

Lines changed: 51 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -290,7 +290,7 @@ static inline const YGValue *YGComputedEdgeValue(const YGValue edges[YGEdgeCount
290290
return defaultValue;
291291
}
292292

293-
static inline float YGValueResolve(const YGValue *const value, const float parentSize) {
293+
static inline float YGResolveValue(const YGValue *const value, const float parentSize) {
294294
switch (value->unit) {
295295
case YGUnitUndefined:
296296
case YGUnitAuto:
@@ -303,8 +303,8 @@ static inline float YGValueResolve(const YGValue *const value, const float paren
303303
return YGUndefined;
304304
}
305305

306-
static inline float YGValueResolveMargin(const YGValue *const value, const float parentSize) {
307-
return value->unit == YGUnitAuto ? 0 : YGValueResolve(value, parentSize);
306+
static inline float YGResolveValueMargin(const YGValue *const value, const float parentSize) {
307+
return value->unit == YGUnitAuto ? 0 : YGResolveValue(value, parentSize);
308308
}
309309

310310
int32_t gNodeInstanceCount = 0;
@@ -1001,33 +1001,33 @@ static inline float YGNodeLeadingMargin(const YGNodeRef node,
10011001
const YGFlexDirection axis,
10021002
const float widthSize) {
10031003
if (YGFlexDirectionIsRow(axis) && node->style.margin[YGEdgeStart].unit != YGUnitUndefined) {
1004-
return YGValueResolveMargin(&node->style.margin[YGEdgeStart], widthSize);
1004+
return YGResolveValueMargin(&node->style.margin[YGEdgeStart], widthSize);
10051005
}
10061006

1007-
return YGValueResolveMargin(YGComputedEdgeValue(node->style.margin, leading[axis], &YGValueZero),
1007+
return YGResolveValueMargin(YGComputedEdgeValue(node->style.margin, leading[axis], &YGValueZero),
10081008
widthSize);
10091009
}
10101010

10111011
static float YGNodeTrailingMargin(const YGNodeRef node,
10121012
const YGFlexDirection axis,
10131013
const float widthSize) {
10141014
if (YGFlexDirectionIsRow(axis) && node->style.margin[YGEdgeEnd].unit != YGUnitUndefined) {
1015-
return YGValueResolveMargin(&node->style.margin[YGEdgeEnd], widthSize);
1015+
return YGResolveValueMargin(&node->style.margin[YGEdgeEnd], widthSize);
10161016
}
10171017

1018-
return YGValueResolveMargin(YGComputedEdgeValue(node->style.margin, trailing[axis], &YGValueZero),
1018+
return YGResolveValueMargin(YGComputedEdgeValue(node->style.margin, trailing[axis], &YGValueZero),
10191019
widthSize);
10201020
}
10211021

10221022
static float YGNodeLeadingPadding(const YGNodeRef node,
10231023
const YGFlexDirection axis,
10241024
const float widthSize) {
10251025
if (YGFlexDirectionIsRow(axis) && node->style.padding[YGEdgeStart].unit != YGUnitUndefined &&
1026-
YGValueResolve(&node->style.padding[YGEdgeStart], widthSize) >= 0.0f) {
1027-
return YGValueResolve(&node->style.padding[YGEdgeStart], widthSize);
1026+
YGResolveValue(&node->style.padding[YGEdgeStart], widthSize) >= 0.0f) {
1027+
return YGResolveValue(&node->style.padding[YGEdgeStart], widthSize);
10281028
}
10291029

1030-
return fmaxf(YGValueResolve(YGComputedEdgeValue(node->style.padding, leading[axis], &YGValueZero),
1030+
return fmaxf(YGResolveValue(YGComputedEdgeValue(node->style.padding, leading[axis], &YGValueZero),
10311031
widthSize),
10321032
0.0f);
10331033
}
@@ -1036,11 +1036,11 @@ static float YGNodeTrailingPadding(const YGNodeRef node,
10361036
const YGFlexDirection axis,
10371037
const float widthSize) {
10381038
if (YGFlexDirectionIsRow(axis) && node->style.padding[YGEdgeEnd].unit != YGUnitUndefined &&
1039-
YGValueResolve(&node->style.padding[YGEdgeEnd], widthSize) >= 0.0f) {
1040-
return YGValueResolve(&node->style.padding[YGEdgeEnd], widthSize);
1039+
YGResolveValue(&node->style.padding[YGEdgeEnd], widthSize) >= 0.0f) {
1040+
return YGResolveValue(&node->style.padding[YGEdgeEnd], widthSize);
10411041
}
10421042

1043-
return fmaxf(YGValueResolve(YGComputedEdgeValue(node->style.padding, trailing[axis], &YGValueZero),
1043+
return fmaxf(YGResolveValue(YGComputedEdgeValue(node->style.padding, trailing[axis], &YGValueZero),
10441044
widthSize),
10451045
0.0f);
10461046
}
@@ -1143,7 +1143,7 @@ static float YGBaseline(const YGNodeRef node) {
11431143
return baseline + baselineChild->layout.position[YGEdgeTop];
11441144
}
11451145

1146-
static inline YGFlexDirection YGFlexDirectionResolve(const YGFlexDirection flexDirection,
1146+
static inline YGFlexDirection YGResolveFlexDirection(const YGFlexDirection flexDirection,
11471147
const YGDirection direction) {
11481148
if (direction == YGDirectionRTL) {
11491149
if (flexDirection == YGFlexDirectionRow) {
@@ -1159,7 +1159,7 @@ static inline YGFlexDirection YGFlexDirectionResolve(const YGFlexDirection flexD
11591159
static YGFlexDirection YGFlexDirectionCross(const YGFlexDirection flexDirection,
11601160
const YGDirection direction) {
11611161
return YGFlexDirectionIsColumn(flexDirection)
1162-
? YGFlexDirectionResolve(YGFlexDirectionRow, direction)
1162+
? YGResolveFlexDirection(YGFlexDirectionRow, direction)
11631163
: YGFlexDirectionColumn;
11641164
}
11651165

@@ -1233,15 +1233,15 @@ static float YGNodeLeadingPosition(const YGNodeRef node,
12331233
const YGValue *leadingPosition =
12341234
YGComputedEdgeValue(node->style.position, YGEdgeStart, &YGValueUndefined);
12351235
if (leadingPosition->unit != YGUnitUndefined) {
1236-
return YGValueResolve(leadingPosition, axisSize);
1236+
return YGResolveValue(leadingPosition, axisSize);
12371237
}
12381238
}
12391239

12401240
const YGValue *leadingPosition =
12411241
YGComputedEdgeValue(node->style.position, leading[axis], &YGValueUndefined);
12421242

12431243
return leadingPosition->unit == YGUnitUndefined ? 0.0f
1244-
: YGValueResolve(leadingPosition, axisSize);
1244+
: YGResolveValue(leadingPosition, axisSize);
12451245
}
12461246

12471247
static float YGNodeTrailingPosition(const YGNodeRef node,
@@ -1251,15 +1251,15 @@ static float YGNodeTrailingPosition(const YGNodeRef node,
12511251
const YGValue *trailingPosition =
12521252
YGComputedEdgeValue(node->style.position, YGEdgeEnd, &YGValueUndefined);
12531253
if (trailingPosition->unit != YGUnitUndefined) {
1254-
return YGValueResolve(trailingPosition, axisSize);
1254+
return YGResolveValue(trailingPosition, axisSize);
12551255
}
12561256
}
12571257

12581258
const YGValue *trailingPosition =
12591259
YGComputedEdgeValue(node->style.position, trailing[axis], &YGValueUndefined);
12601260

12611261
return trailingPosition->unit == YGUnitUndefined ? 0.0f
1262-
: YGValueResolve(trailingPosition, axisSize);
1262+
: YGResolveValue(trailingPosition, axisSize);
12631263
}
12641264

12651265
static float YGNodeBoundAxisWithinMinAndMax(const YGNodeRef node,
@@ -1270,11 +1270,11 @@ static float YGNodeBoundAxisWithinMinAndMax(const YGNodeRef node,
12701270
float max = YGUndefined;
12711271

12721272
if (YGFlexDirectionIsColumn(axis)) {
1273-
min = YGValueResolve(&node->style.minDimensions[YGDimensionHeight], axisSize);
1274-
max = YGValueResolve(&node->style.maxDimensions[YGDimensionHeight], axisSize);
1273+
min = YGResolveValue(&node->style.minDimensions[YGDimensionHeight], axisSize);
1274+
max = YGResolveValue(&node->style.maxDimensions[YGDimensionHeight], axisSize);
12751275
} else if (YGFlexDirectionIsRow(axis)) {
1276-
min = YGValueResolve(&node->style.minDimensions[YGDimensionWidth], axisSize);
1277-
max = YGValueResolve(&node->style.maxDimensions[YGDimensionWidth], axisSize);
1276+
min = YGResolveValue(&node->style.minDimensions[YGDimensionWidth], axisSize);
1277+
max = YGResolveValue(&node->style.maxDimensions[YGDimensionWidth], axisSize);
12781278
}
12791279

12801280
float boundValue = value;
@@ -1341,7 +1341,7 @@ static void YGConstrainMaxSizeForMode(const YGNodeRef node,
13411341
const float parentWidth,
13421342
YGMeasureMode *mode,
13431343
float *size) {
1344-
const float maxSize = YGValueResolve(&node->style.maxDimensions[dim[axis]], parentAxisSize) +
1344+
const float maxSize = YGResolveValue(&node->style.maxDimensions[dim[axis]], parentAxisSize) +
13451345
YGNodeMarginForAxis(node, axis, parentWidth);
13461346
switch (*mode) {
13471347
case YGMeasureModeExactly:
@@ -1362,7 +1362,7 @@ static void YGNodeSetPosition(const YGNodeRef node,
13621362
const float mainSize,
13631363
const float crossSize,
13641364
const float parentWidth) {
1365-
const YGFlexDirection mainAxis = YGFlexDirectionResolve(node->style.flexDirection, direction);
1365+
const YGFlexDirection mainAxis = YGResolveFlexDirection(node->style.flexDirection, direction);
13661366
const YGFlexDirection crossAxis = YGFlexDirectionCross(mainAxis, direction);
13671367
const float relativePositionMain = YGNodeRelativePosition(node, mainAxis, mainSize);
13681368
const float relativePositionCross = YGNodeRelativePosition(node, crossAxis, crossSize);
@@ -1387,7 +1387,7 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node,
13871387
const YGMeasureMode heightMode,
13881388
const YGDirection direction,
13891389
const YGConfigRef config) {
1390-
const YGFlexDirection mainAxis = YGFlexDirectionResolve(node->style.flexDirection, direction);
1390+
const YGFlexDirection mainAxis = YGResolveFlexDirection(node->style.flexDirection, direction);
13911391
const bool isMainAxisRow = YGFlexDirectionIsRow(mainAxis);
13921392
const float mainAxisSize = isMainAxisRow ? width : height;
13931393
const float mainAxisParentSize = isMainAxisRow ? parentWidth : parentHeight;
@@ -1398,7 +1398,7 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node,
13981398
YGMeasureMode childHeightMeasureMode;
13991399

14001400
const float resolvedFlexBasis =
1401-
YGValueResolve(YGNodeResolveFlexBasisPtr(child), mainAxisParentSize);
1401+
YGResolveValue(YGNodeResolveFlexBasisPtr(child), mainAxisParentSize);
14021402
const bool isRowStyleDimDefined = YGNodeIsStyleDimDefined(child, YGFlexDirectionRow, parentWidth);
14031403
const bool isColumnStyleDimDefined =
14041404
YGNodeIsStyleDimDefined(child, YGFlexDirectionColumn, parentHeight);
@@ -1413,12 +1413,12 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node,
14131413
} else if (isMainAxisRow && isRowStyleDimDefined) {
14141414
// The width is definite, so use that as the flex basis.
14151415
child->layout.computedFlexBasis =
1416-
fmaxf(YGValueResolve(child->resolvedDimensions[YGDimensionWidth], parentWidth),
1416+
fmaxf(YGResolveValue(child->resolvedDimensions[YGDimensionWidth], parentWidth),
14171417
YGNodePaddingAndBorderForAxis(child, YGFlexDirectionRow, parentWidth));
14181418
} else if (!isMainAxisRow && isColumnStyleDimDefined) {
14191419
// The height is definite, so use that as the flex basis.
14201420
child->layout.computedFlexBasis =
1421-
fmaxf(YGValueResolve(child->resolvedDimensions[YGDimensionHeight], parentHeight),
1421+
fmaxf(YGResolveValue(child->resolvedDimensions[YGDimensionHeight], parentHeight),
14221422
YGNodePaddingAndBorderForAxis(child, YGFlexDirectionColumn, parentWidth));
14231423
} else {
14241424
// Compute the flex basis and hypothetical main size (i.e. the clamped
@@ -1433,12 +1433,12 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node,
14331433

14341434
if (isRowStyleDimDefined) {
14351435
childWidth =
1436-
YGValueResolve(child->resolvedDimensions[YGDimensionWidth], parentWidth) + marginRow;
1436+
YGResolveValue(child->resolvedDimensions[YGDimensionWidth], parentWidth) + marginRow;
14371437
childWidthMeasureMode = YGMeasureModeExactly;
14381438
}
14391439
if (isColumnStyleDimDefined) {
14401440
childHeight =
1441-
YGValueResolve(child->resolvedDimensions[YGDimensionHeight], parentHeight) + marginColumn;
1441+
YGResolveValue(child->resolvedDimensions[YGDimensionHeight], parentHeight) + marginColumn;
14421442
childHeightMeasureMode = YGMeasureModeExactly;
14431443
}
14441444

@@ -1521,7 +1521,7 @@ static void YGNodeAbsoluteLayoutChild(const YGNodeRef node,
15211521
const float height,
15221522
const YGDirection direction,
15231523
const YGConfigRef config) {
1524-
const YGFlexDirection mainAxis = YGFlexDirectionResolve(node->style.flexDirection, direction);
1524+
const YGFlexDirection mainAxis = YGResolveFlexDirection(node->style.flexDirection, direction);
15251525
const YGFlexDirection crossAxis = YGFlexDirectionCross(mainAxis, direction);
15261526
const bool isMainAxisRow = YGFlexDirectionIsRow(mainAxis);
15271527

@@ -1534,7 +1534,7 @@ static void YGNodeAbsoluteLayoutChild(const YGNodeRef node,
15341534
const float marginColumn = YGNodeMarginForAxis(child, YGFlexDirectionColumn, width);
15351535

15361536
if (YGNodeIsStyleDimDefined(child, YGFlexDirectionRow, width)) {
1537-
childWidth = YGValueResolve(child->resolvedDimensions[YGDimensionWidth], width) + marginRow;
1537+
childWidth = YGResolveValue(child->resolvedDimensions[YGDimensionWidth], width) + marginRow;
15381538
} else {
15391539
// If the child doesn't have a specified width, compute the width based
15401540
// on the left/right
@@ -1552,7 +1552,7 @@ static void YGNodeAbsoluteLayoutChild(const YGNodeRef node,
15521552

15531553
if (YGNodeIsStyleDimDefined(child, YGFlexDirectionColumn, height)) {
15541554
childHeight =
1555-
YGValueResolve(child->resolvedDimensions[YGDimensionHeight], height) + marginColumn;
1555+
YGResolveValue(child->resolvedDimensions[YGDimensionHeight], height) + marginColumn;
15561556
} else {
15571557
// If the child doesn't have a specified height, compute the height
15581558
// based on the top/bottom
@@ -1925,9 +1925,9 @@ static void YGNodelayoutImpl(const YGNodeRef node,
19251925
const YGDirection direction = YGNodeResolveDirection(node, parentDirection);
19261926
node->layout.direction = direction;
19271927

1928-
const YGFlexDirection flexRowDirection = YGFlexDirectionResolve(YGFlexDirectionRow, direction);
1928+
const YGFlexDirection flexRowDirection = YGResolveFlexDirection(YGFlexDirectionRow, direction);
19291929
const YGFlexDirection flexColumnDirection =
1930-
YGFlexDirectionResolve(YGFlexDirectionColumn, direction);
1930+
YGResolveFlexDirection(YGFlexDirectionColumn, direction);
19311931

19321932
node->layout.margin[YGEdgeStart] = YGNodeLeadingMargin(node, flexRowDirection, parentWidth);
19331933
node->layout.margin[YGEdgeEnd] = YGNodeTrailingMargin(node, flexRowDirection, parentWidth);
@@ -1981,7 +1981,7 @@ static void YGNodelayoutImpl(const YGNodeRef node,
19811981
}
19821982

19831983
// STEP 1: CALCULATE VALUES FOR REMAINDER OF ALGORITHM
1984-
const YGFlexDirection mainAxis = YGFlexDirectionResolve(node->style.flexDirection, direction);
1984+
const YGFlexDirection mainAxis = YGResolveFlexDirection(node->style.flexDirection, direction);
19851985
const YGFlexDirection crossAxis = YGFlexDirectionCross(mainAxis, direction);
19861986
const bool isMainAxisRow = YGFlexDirectionIsRow(mainAxis);
19871987
const YGJustify justifyContent = node->style.justifyContent;
@@ -2016,16 +2016,16 @@ static void YGNodelayoutImpl(const YGNodeRef node,
20162016

20172017
// STEP 2: DETERMINE AVAILABLE SIZE IN MAIN AND CROSS DIRECTIONS
20182018
const float minInnerWidth =
2019-
YGValueResolve(&node->style.minDimensions[YGDimensionWidth], parentWidth) - marginAxisRow -
2019+
YGResolveValue(&node->style.minDimensions[YGDimensionWidth], parentWidth) - marginAxisRow -
20202020
paddingAndBorderAxisRow;
20212021
const float maxInnerWidth =
2022-
YGValueResolve(&node->style.maxDimensions[YGDimensionWidth], parentWidth) - marginAxisRow -
2022+
YGResolveValue(&node->style.maxDimensions[YGDimensionWidth], parentWidth) - marginAxisRow -
20232023
paddingAndBorderAxisRow;
20242024
const float minInnerHeight =
2025-
YGValueResolve(&node->style.minDimensions[YGDimensionHeight], parentHeight) -
2025+
YGResolveValue(&node->style.minDimensions[YGDimensionHeight], parentHeight) -
20262026
marginAxisColumn - paddingAndBorderAxisColumn;
20272027
const float maxInnerHeight =
2028-
YGValueResolve(&node->style.maxDimensions[YGDimensionHeight], parentHeight) -
2028+
YGResolveValue(&node->style.maxDimensions[YGDimensionHeight], parentHeight) -
20292029
marginAxisColumn - paddingAndBorderAxisColumn;
20302030
const float minInnerMainDim = isMainAxisRow ? minInnerWidth : minInnerHeight;
20312031
const float maxInnerMainDim = isMainAxisRow ? maxInnerWidth : maxInnerHeight;
@@ -2173,7 +2173,7 @@ static void YGNodelayoutImpl(const YGNodeRef node,
21732173

21742174
if (child->style.positionType != YGPositionTypeAbsolute) {
21752175
const float outerFlexBasis =
2176-
fmaxf(YGValueResolve(&child->style.minDimensions[dim[mainAxis]], mainAxisParentSize),
2176+
fmaxf(YGResolveValue(&child->style.minDimensions[dim[mainAxis]], mainAxisParentSize),
21772177
child->layout.computedFlexBasis) +
21782178
YGNodeMarginForAxis(child, mainAxis, availableInnerWidth);
21792179

@@ -2416,7 +2416,7 @@ static void YGNodelayoutImpl(const YGNodeRef node,
24162416
childCrossMeasureMode =
24172417
YGFloatIsUndefined(childCrossSize) ? YGMeasureModeUndefined : YGMeasureModeAtMost;
24182418
} else {
2419-
childCrossSize = YGValueResolve(currentRelativeChild->resolvedDimensions[dim[crossAxis]],
2419+
childCrossSize = YGResolveValue(currentRelativeChild->resolvedDimensions[dim[crossAxis]],
24202420
availableInnerCrossDim) +
24212421
marginCross;
24222422
const bool isLoosePercentageMeasurement =
@@ -2506,10 +2506,10 @@ static void YGNodelayoutImpl(const YGNodeRef node,
25062506

25072507
if (measureModeMainDim == YGMeasureModeAtMost && remainingFreeSpace > 0) {
25082508
if (node->style.minDimensions[dim[mainAxis]].unit != YGUnitUndefined &&
2509-
YGValueResolve(&node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) >= 0) {
2509+
YGResolveValue(&node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) >= 0) {
25102510
remainingFreeSpace =
25112511
fmaxf(0,
2512-
YGValueResolve(&node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) -
2512+
YGResolveValue(&node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) -
25132513
(availableInnerMainDim - remainingFreeSpace));
25142514
} else {
25152515
remainingFreeSpace = 0;
@@ -3386,11 +3386,11 @@ void YGNodeCalculateLayout(const YGNodeRef node,
33863386
float width = YGUndefined;
33873387
YGMeasureMode widthMeasureMode = YGMeasureModeUndefined;
33883388
if (YGNodeIsStyleDimDefined(node, YGFlexDirectionRow, parentWidth)) {
3389-
width = YGValueResolve(node->resolvedDimensions[dim[YGFlexDirectionRow]], parentWidth) +
3389+
width = YGResolveValue(node->resolvedDimensions[dim[YGFlexDirectionRow]], parentWidth) +
33903390
YGNodeMarginForAxis(node, YGFlexDirectionRow, parentWidth);
33913391
widthMeasureMode = YGMeasureModeExactly;
3392-
} else if (YGValueResolve(&node->style.maxDimensions[YGDimensionWidth], parentWidth) >= 0.0f) {
3393-
width = YGValueResolve(&node->style.maxDimensions[YGDimensionWidth], parentWidth);
3392+
} else if (YGResolveValue(&node->style.maxDimensions[YGDimensionWidth], parentWidth) >= 0.0f) {
3393+
width = YGResolveValue(&node->style.maxDimensions[YGDimensionWidth], parentWidth);
33943394
widthMeasureMode = YGMeasureModeAtMost;
33953395
} else {
33963396
width = parentWidth;
@@ -3400,12 +3400,12 @@ void YGNodeCalculateLayout(const YGNodeRef node,
34003400
float height = YGUndefined;
34013401
YGMeasureMode heightMeasureMode = YGMeasureModeUndefined;
34023402
if (YGNodeIsStyleDimDefined(node, YGFlexDirectionColumn, parentHeight)) {
3403-
height = YGValueResolve(node->resolvedDimensions[dim[YGFlexDirectionColumn]], parentHeight) +
3403+
height = YGResolveValue(node->resolvedDimensions[dim[YGFlexDirectionColumn]], parentHeight) +
34043404
YGNodeMarginForAxis(node, YGFlexDirectionColumn, parentWidth);
34053405
heightMeasureMode = YGMeasureModeExactly;
3406-
} else if (YGValueResolve(&node->style.maxDimensions[YGDimensionHeight], parentHeight) >=
3406+
} else if (YGResolveValue(&node->style.maxDimensions[YGDimensionHeight], parentHeight) >=
34073407
0.0f) {
3408-
height = YGValueResolve(&node->style.maxDimensions[YGDimensionHeight], parentHeight);
3408+
height = YGResolveValue(&node->style.maxDimensions[YGDimensionHeight], parentHeight);
34093409
heightMeasureMode = YGMeasureModeAtMost;
34103410
} else {
34113411
height = parentHeight;

0 commit comments

Comments
 (0)