Skip to content

Commit

Permalink
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Remove yoga::Style::BitfieldRef
Browse files Browse the repository at this point in the history
Summary: Removes the last of the non setter-style style setters.

Differential Revision: D51155925

fbshipit-source-id: 8d757fe95c0119b56a8f69607e517f8a095c962e
NickGerleman authored and facebook-github-bot committed Nov 9, 2023
1 parent d61bdbf commit f5b31e7
Showing 3 changed files with 88 additions and 129 deletions.
132 changes: 52 additions & 80 deletions yoga/YGNodeStyle.cpp
Original file line number Diff line number Diff line change
@@ -14,54 +14,26 @@ using namespace facebook::yoga;

namespace {

template <typename T, typename NeedsUpdate, typename Update>
void updateStyle(
yoga::Node* node,
T value,
NeedsUpdate&& needsUpdate,
Update&& update) {
if (needsUpdate(node->getStyle(), value)) {
update(node->getStyle(), value);
node->markDirtyAndPropagate();
}
}

template <typename Ref, typename ValueT>
void updateStyle(YGNodeRef node, Ref (Style::*prop)(), ValueT value) {
updateStyle(
resolveRef(node),
value,
[prop](Style& s, ValueT x) { return (s.*prop)() != x; },
[prop](Style& s, ValueT x) { (s.*prop)() = x; });
}

template <auto GetterT, auto SetterT, typename ValueT>
void updateStyle(YGNodeRef node, ValueT value) {
updateStyle(
resolveRef(node),
value,
[](Style& s, ValueT x) { return (s.*GetterT)() != x; },
[](Style& s, ValueT x) { (s.*SetterT)(x); });
auto& style = resolveRef(node)->getStyle();
if ((style.*GetterT)() != value) {
(style.*SetterT)(value);
resolveRef(node)->markDirtyAndPropagate();
}
}

template <auto GetterT, auto SetterT, typename IdxT, typename ValueT>
void updateIndexedStyleProp(YGNodeRef node, IdxT idx, ValueT value) {
updateStyle(
resolveRef(node),
value,
[idx](Style& s, ValueT x) { return (s.*GetterT)(idx) != x; },
[idx](Style& s, ValueT x) { (s.*SetterT)(idx, x); });
void updateStyle(YGNodeRef node, IdxT idx, ValueT value) {
auto& style = resolveRef(node)->getStyle();
if ((style.*GetterT)(idx) != value) {
(style.*SetterT)(idx, value);
resolveRef(node)->markDirtyAndPropagate();
}
}

} // namespace

// MSVC has trouble inferring the return type of pointer to member functions
// with const and non-const overloads, instead of preferring the non-const
// 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(Style{}.PROP())

void YGNodeCopyStyle(
const YGNodeRef dstNodeRef,
const YGNodeConstRef srcNodeRef) {
@@ -75,7 +47,7 @@ void YGNodeCopyStyle(
}

void YGNodeStyleSetDirection(const YGNodeRef node, const YGDirection value) {
updateStyle<MSVC_HINT(direction)>(node, &Style::direction, scopedEnum(value));
updateStyle<&Style::direction, &Style::setDirection>(node, scopedEnum(value));
}

YGDirection YGNodeStyleGetDirection(const YGNodeConstRef node) {
@@ -85,8 +57,8 @@ YGDirection YGNodeStyleGetDirection(const YGNodeConstRef node) {
void YGNodeStyleSetFlexDirection(
const YGNodeRef node,
const YGFlexDirection flexDirection) {
updateStyle<MSVC_HINT(flexDirection)>(
node, &Style::flexDirection, scopedEnum(flexDirection));
updateStyle<&Style::flexDirection, &Style::setFlexDirection>(
node, scopedEnum(flexDirection));
}

YGFlexDirection YGNodeStyleGetFlexDirection(const YGNodeConstRef node) {
@@ -96,8 +68,8 @@ YGFlexDirection YGNodeStyleGetFlexDirection(const YGNodeConstRef node) {
void YGNodeStyleSetJustifyContent(
const YGNodeRef node,
const YGJustify justifyContent) {
updateStyle<MSVC_HINT(justifyContent)>(
node, &Style::justifyContent, scopedEnum(justifyContent));
updateStyle<&Style::justifyContent, &Style::setJustifyContent>(
node, scopedEnum(justifyContent));
}

YGJustify YGNodeStyleGetJustifyContent(const YGNodeConstRef node) {
@@ -107,26 +79,26 @@ YGJustify YGNodeStyleGetJustifyContent(const YGNodeConstRef node) {
void YGNodeStyleSetAlignContent(
const YGNodeRef node,
const YGAlign alignContent) {
updateStyle<MSVC_HINT(alignContent)>(
node, &Style::alignContent, scopedEnum(alignContent));
updateStyle<&Style::alignContent, &Style::setAlignContent>(
node, scopedEnum(alignContent));
}

YGAlign YGNodeStyleGetAlignContent(const YGNodeConstRef node) {
return unscopedEnum(resolveRef(node)->getStyle().alignContent());
}

void YGNodeStyleSetAlignItems(const YGNodeRef node, const YGAlign alignItems) {
updateStyle<MSVC_HINT(alignItems)>(
node, &Style::alignItems, scopedEnum(alignItems));
updateStyle<&Style::alignItems, &Style::setAlignItems>(
node, scopedEnum(alignItems));
}

YGAlign YGNodeStyleGetAlignItems(const YGNodeConstRef node) {
return unscopedEnum(resolveRef(node)->getStyle().alignItems());
}

void YGNodeStyleSetAlignSelf(const YGNodeRef node, const YGAlign alignSelf) {
updateStyle<MSVC_HINT(alignSelf)>(
node, &Style::alignSelf, scopedEnum(alignSelf));
updateStyle<&Style::alignSelf, &Style::setAlignSelf>(
node, scopedEnum(alignSelf));
}

YGAlign YGNodeStyleGetAlignSelf(const YGNodeConstRef node) {
@@ -136,34 +108,34 @@ YGAlign YGNodeStyleGetAlignSelf(const YGNodeConstRef node) {
void YGNodeStyleSetPositionType(
const YGNodeRef node,
const YGPositionType positionType) {
updateStyle<MSVC_HINT(positionType)>(
node, &Style::positionType, scopedEnum(positionType));
updateStyle<&Style::positionType, &Style::setPositionType>(
node, scopedEnum(positionType));
}

YGPositionType YGNodeStyleGetPositionType(const YGNodeConstRef node) {
return unscopedEnum(resolveRef(node)->getStyle().positionType());
}

void YGNodeStyleSetFlexWrap(const YGNodeRef node, const YGWrap flexWrap) {
updateStyle<MSVC_HINT(flexWrap)>(
node, &Style::flexWrap, scopedEnum(flexWrap));
updateStyle<&Style::flexWrap, &Style::setFlexWrap>(
node, scopedEnum(flexWrap));
}

YGWrap YGNodeStyleGetFlexWrap(const YGNodeConstRef node) {
return unscopedEnum(resolveRef(node)->getStyle().flexWrap());
}

void YGNodeStyleSetOverflow(const YGNodeRef node, const YGOverflow overflow) {
updateStyle<MSVC_HINT(overflow)>(
node, &Style::overflow, scopedEnum(overflow));
updateStyle<&Style::overflow, &Style::setOverflow>(
node, scopedEnum(overflow));
}

YGOverflow YGNodeStyleGetOverflow(const YGNodeConstRef node) {
return unscopedEnum(resolveRef(node)->getStyle().overflow());
}

void YGNodeStyleSetDisplay(const YGNodeRef node, const YGDisplay display) {
updateStyle<MSVC_HINT(display)>(node, &Style::display, scopedEnum(display));
updateStyle<&Style::display, &Style::setDisplay>(node, scopedEnum(display));
}

YGDisplay YGNodeStyleGetDisplay(const YGNodeConstRef node) {
@@ -231,12 +203,12 @@ YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) {
}

void YGNodeStyleSetPosition(YGNodeRef node, YGEdge edge, float points) {
updateIndexedStyleProp<&Style::position, &Style::setPosition>(
updateStyle<&Style::position, &Style::setPosition>(
node, scopedEnum(edge), value::points(points));
}

void YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge, float percent) {
updateIndexedStyleProp<&Style::position, &Style::setPosition>(
updateStyle<&Style::position, &Style::setPosition>(
node, scopedEnum(edge), value::percent(percent));
}

@@ -245,17 +217,17 @@ YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) {
}

void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float points) {
updateIndexedStyleProp<&Style::margin, &Style::setMargin>(
updateStyle<&Style::margin, &Style::setMargin>(
node, scopedEnum(edge), value::points(points));
}

void YGNodeStyleSetMarginPercent(YGNodeRef node, YGEdge edge, float percent) {
updateIndexedStyleProp<&Style::margin, &Style::setMargin>(
updateStyle<&Style::margin, &Style::setMargin>(
node, scopedEnum(edge), value::percent(percent));
}

void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge) {
updateIndexedStyleProp<&Style::margin, &Style::setMargin>(
updateStyle<&Style::margin, &Style::setMargin>(
node, scopedEnum(edge), value::ofAuto());
}

@@ -264,12 +236,12 @@ YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge) {
}

void YGNodeStyleSetPadding(YGNodeRef node, YGEdge edge, float points) {
updateIndexedStyleProp<&Style::padding, &Style::setPadding>(
updateStyle<&Style::padding, &Style::setPadding>(
node, scopedEnum(edge), value::points(points));
}

void YGNodeStyleSetPaddingPercent(YGNodeRef node, YGEdge edge, float percent) {
updateIndexedStyleProp<&Style::padding, &Style::setPadding>(
updateStyle<&Style::padding, &Style::setPadding>(
node, scopedEnum(edge), value::percent(percent));
}

@@ -281,7 +253,7 @@ void YGNodeStyleSetBorder(
const YGNodeRef node,
const YGEdge edge,
const float border) {
updateIndexedStyleProp<&Style::border, &Style::setBorder>(
updateStyle<&Style::border, &Style::setBorder>(
node, scopedEnum(edge), value::points(border));
}

@@ -298,7 +270,7 @@ void YGNodeStyleSetGap(
const YGNodeRef node,
const YGGutter gutter,
const float gapLength) {
updateIndexedStyleProp<&Style::gap, &Style::setGap>(
updateStyle<&Style::gap, &Style::setGap>(
node, scopedEnum(gutter), value::points(gapLength));
}

@@ -322,17 +294,17 @@ float YGNodeStyleGetAspectRatio(const YGNodeConstRef node) {
}

void YGNodeStyleSetWidth(YGNodeRef node, float points) {
updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
updateStyle<&Style::dimension, &Style::setDimension>(
node, Dimension::Width, value::points(points));
}

void YGNodeStyleSetWidthPercent(YGNodeRef node, float percent) {
updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
updateStyle<&Style::dimension, &Style::setDimension>(
node, Dimension::Width, value::percent(percent));
}

void YGNodeStyleSetWidthAuto(YGNodeRef node) {
updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
updateStyle<&Style::dimension, &Style::setDimension>(
node, Dimension::Width, value::ofAuto());
}

@@ -341,17 +313,17 @@ YGValue YGNodeStyleGetWidth(YGNodeConstRef node) {
}

void YGNodeStyleSetHeight(YGNodeRef node, float points) {
updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
updateStyle<&Style::dimension, &Style::setDimension>(
node, Dimension::Height, value::points(points));
}

void YGNodeStyleSetHeightPercent(YGNodeRef node, float percent) {
updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
updateStyle<&Style::dimension, &Style::setDimension>(
node, Dimension::Height, value::percent(percent));
}

void YGNodeStyleSetHeightAuto(YGNodeRef node) {
updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
updateStyle<&Style::dimension, &Style::setDimension>(
node, Dimension::Height, value::ofAuto());
}

@@ -360,12 +332,12 @@ YGValue YGNodeStyleGetHeight(YGNodeConstRef node) {
}

void YGNodeStyleSetMinWidth(const YGNodeRef node, const float minWidth) {
updateIndexedStyleProp<&Style::minDimension, &Style::setMinDimension>(
updateStyle<&Style::minDimension, &Style::setMinDimension>(
node, Dimension::Width, value::points(minWidth));
}

void YGNodeStyleSetMinWidthPercent(const YGNodeRef node, const float minWidth) {
updateIndexedStyleProp<&Style::minDimension, &Style::setMinDimension>(
updateStyle<&Style::minDimension, &Style::setMinDimension>(
node, Dimension::Width, value::percent(minWidth));
}

@@ -374,14 +346,14 @@ YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) {
}

void YGNodeStyleSetMinHeight(const YGNodeRef node, const float minHeight) {
updateIndexedStyleProp<&Style::minDimension, &Style::setMinDimension>(
updateStyle<&Style::minDimension, &Style::setMinDimension>(
node, Dimension::Height, value::points(minHeight));
}

void YGNodeStyleSetMinHeightPercent(
const YGNodeRef node,
const float minHeight) {
updateIndexedStyleProp<&Style::minDimension, &Style::setMinDimension>(
updateStyle<&Style::minDimension, &Style::setMinDimension>(
node, Dimension::Height, value::percent(minHeight));
}

@@ -390,12 +362,12 @@ YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) {
}

void YGNodeStyleSetMaxWidth(const YGNodeRef node, const float maxWidth) {
updateIndexedStyleProp<&Style::maxDimension, &Style::setMaxDimension>(
updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
node, Dimension::Width, value::points(maxWidth));
}

void YGNodeStyleSetMaxWidthPercent(const YGNodeRef node, const float maxWidth) {
updateIndexedStyleProp<&Style::maxDimension, &Style::setMaxDimension>(
updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
node, Dimension::Width, value::percent(maxWidth));
}

@@ -404,14 +376,14 @@ YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) {
}

void YGNodeStyleSetMaxHeight(const YGNodeRef node, const float maxHeight) {
updateIndexedStyleProp<&Style::maxDimension, &Style::setMaxDimension>(
updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
node, Dimension::Height, value::points(maxHeight));
}

void YGNodeStyleSetMaxHeightPercent(
const YGNodeRef node,
const float maxHeight) {
updateIndexedStyleProp<&Style::maxDimension, &Style::setMaxDimension>(
updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
node, Dimension::Height, value::percent(maxHeight));
}

4 changes: 2 additions & 2 deletions yoga/node/Node.h
Original file line number Diff line number Diff line change
@@ -61,8 +61,8 @@ class YG_EXPORT Node : public ::YGNode {
Direction direction) const;

void useWebDefaults() {
style_.flexDirection() = FlexDirection::Row;
style_.alignContent() = Align::Stretch;
style_.setFlexDirection(FlexDirection::Row);
style_.setAlignContent(Align::Stretch);
}

template <auto Field>
81 changes: 34 additions & 47 deletions yoga/style/Style.h
Original file line number Diff line number Diff line change
@@ -55,22 +55,9 @@ class YG_EXPORT Style {
static constexpr float DefaultFlexShrink = 0.0f;
static constexpr float WebDefaultFlexShrink = 1.0f;

template <typename T>
struct BitfieldRef {
Style& style;
uint8_t offset;
operator T() const {
return getEnumData<T>(style.flags, offset);
}
BitfieldRef<T>& operator=(T x) {
setEnumData<T>(style.flags, offset, x);
return *this;
}
};

Style() {
alignContent() = Align::FlexStart;
alignItems() = Align::Stretch;
setAlignContent(Align::FlexStart);
setAlignItems(Align::Stretch);
}
~Style() = default;

@@ -99,7 +86,7 @@ class YG_EXPORT Style {
static constexpr uint8_t displayOffset =
overflowOffset + minimumBitCount<Overflow>();

uint32_t flags = 0;
uint32_t flags_ = 0;

FloatOptional flex_ = {};
FloatOptional flexGrow_ = {};
@@ -118,73 +105,73 @@ class YG_EXPORT Style {

public:
Direction direction() const {
return getEnumData<Direction>(flags, directionOffset);
return getEnumData<Direction>(flags_, directionOffset);
}
BitfieldRef<Direction> direction() {
return {*this, directionOffset};
void setDirection(Direction value) {
setEnumData<Direction>(flags_, directionOffset, value);
}

FlexDirection flexDirection() const {
return getEnumData<FlexDirection>(flags, flexdirectionOffset);
return getEnumData<FlexDirection>(flags_, flexdirectionOffset);
}
BitfieldRef<FlexDirection> flexDirection() {
return {*this, flexdirectionOffset};
void setFlexDirection(FlexDirection value) {
setEnumData<FlexDirection>(flags_, flexdirectionOffset, value);
}

Justify justifyContent() const {
return getEnumData<Justify>(flags, justifyContentOffset);
return getEnumData<Justify>(flags_, justifyContentOffset);
}
BitfieldRef<Justify> justifyContent() {
return {*this, justifyContentOffset};
void setJustifyContent(Justify value) {
setEnumData<Justify>(flags_, justifyContentOffset, value);
}

Align alignContent() const {
return getEnumData<Align>(flags, alignContentOffset);
return getEnumData<Align>(flags_, alignContentOffset);
}
BitfieldRef<Align> alignContent() {
return {*this, alignContentOffset};
void setAlignContent(Align value) {
setEnumData<Align>(flags_, alignContentOffset, value);
}

Align alignItems() const {
return getEnumData<Align>(flags, alignItemsOffset);
return getEnumData<Align>(flags_, alignItemsOffset);
}
BitfieldRef<Align> alignItems() {
return {*this, alignItemsOffset};
void setAlignItems(Align value) {
setEnumData<Align>(flags_, alignItemsOffset, value);
}

Align alignSelf() const {
return getEnumData<Align>(flags, alignSelfOffset);
return getEnumData<Align>(flags_, alignSelfOffset);
}
BitfieldRef<Align> alignSelf() {
return {*this, alignSelfOffset};
void setAlignSelf(Align value) {
setEnumData<Align>(flags_, alignSelfOffset, value);
}

PositionType positionType() const {
return getEnumData<PositionType>(flags, positionTypeOffset);
return getEnumData<PositionType>(flags_, positionTypeOffset);
}
BitfieldRef<PositionType> positionType() {
return {*this, positionTypeOffset};
void setPositionType(PositionType value) {
setEnumData<PositionType>(flags_, positionTypeOffset, value);
}

Wrap flexWrap() const {
return getEnumData<Wrap>(flags, flexWrapOffset);
return getEnumData<Wrap>(flags_, flexWrapOffset);
}
BitfieldRef<Wrap> flexWrap() {
return {*this, flexWrapOffset};
void setFlexWrap(Wrap value) {
setEnumData<Wrap>(flags_, flexWrapOffset, value);
}

Overflow overflow() const {
return getEnumData<Overflow>(flags, overflowOffset);
return getEnumData<Overflow>(flags_, overflowOffset);
}
BitfieldRef<Overflow> overflow() {
return {*this, overflowOffset};
void setOverflow(Overflow value) {
setEnumData<Overflow>(flags_, overflowOffset, value);
}

Display display() const {
return getEnumData<Display>(flags, displayOffset);
return getEnumData<Display>(flags_, displayOffset);
}
BitfieldRef<Display> display() {
return {*this, displayOffset};
void setDisplay(Display value) {
setEnumData<Display>(flags_, displayOffset, value);
}

FloatOptional flex() const {
@@ -295,7 +282,7 @@ class YG_EXPORT Style {
}

bool operator==(const Style& other) const {
return flags == other.flags && inexactEquals(flex_, other.flex_) &&
return flags_ == other.flags_ && inexactEquals(flex_, other.flex_) &&
inexactEquals(flexGrow_, other.flexGrow_) &&
inexactEquals(flexShrink_, other.flexShrink_) &&
inexactEquals(flexBasis_, other.flexBasis_) &&

0 comments on commit f5b31e7

Please sign in to comment.