diff --git a/packages/react-native/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJNIVanilla.cpp b/packages/react-native/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJNIVanilla.cpp index 5d802784154..b1cdc2dacf0 100644 --- a/packages/react-native/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJNIVanilla.cpp +++ b/packages/react-native/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJNIVanilla.cpp @@ -17,7 +17,7 @@ // TODO: Reconcile missing layoutContext functionality from callbacks in the C // API and use that -#include +#include using namespace facebook; using namespace facebook::yoga; @@ -688,7 +688,7 @@ static void jni_YGNodeSetHasMeasureFuncJNI( jobject /*obj*/, jlong nativePointer, jboolean hasMeasureFunc) { - _jlong2YGNodeRef(nativePointer) + static_cast(_jlong2YGNodeRef(nativePointer)) ->setMeasureFunc(hasMeasureFunc ? YGJNIMeasureFunc : nullptr); } @@ -715,7 +715,7 @@ static void jni_YGNodeSetHasBaselineFuncJNI( jobject /*obj*/, jlong nativePointer, jboolean hasBaselineFunc) { - _jlong2YGNodeRef(nativePointer) + static_cast(_jlong2YGNodeRef(nativePointer)) ->setBaselineFunc(hasBaselineFunc ? YGJNIBaselineFunc : nullptr); } diff --git a/packages/react-native/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJTypesVanilla.h b/packages/react-native/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJTypesVanilla.h index 506c304909a..c1534fea692 100644 --- a/packages/react-native/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJTypesVanilla.h +++ b/packages/react-native/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJTypesVanilla.h @@ -14,11 +14,12 @@ #include "jni.h" class PtrJNodeMapVanilla { - std::map ptrsToIdxs_; - jobjectArray javaNodes_; + std::map ptrsToIdxs_{}; + jobjectArray javaNodes_{}; public: - PtrJNodeMapVanilla() : ptrsToIdxs_{}, javaNodes_{} {} + PtrJNodeMapVanilla() = default; + PtrJNodeMapVanilla(jlongArray javaNativePointers, jobjectArray javaNodes) : javaNodes_{javaNodes} { using namespace facebook::yoga::vanillajni; @@ -30,11 +31,11 @@ public: javaNativePointers, 0, nativePointersSize, nativePointers.data()); for (size_t i = 0; i < nativePointersSize; ++i) { - ptrsToIdxs_[(YGNodeRef) nativePointers[i]] = i; + ptrsToIdxs_[(YGNodeConstRef) nativePointers[i]] = i; } } - facebook::yoga::vanillajni::ScopedLocalRef ref(YGNodeRef node) { + facebook::yoga::vanillajni::ScopedLocalRef ref(YGNodeConstRef node) { using namespace facebook::yoga::vanillajni; JNIEnv* env = getCurrentEnv(); diff --git a/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp b/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp index c081352b6d7..ad21539308f 100644 --- a/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp +++ b/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp @@ -82,7 +82,7 @@ YogaLayoutableShadowNode::YogaLayoutableShadowNode( yogaNode_.setContext(this); // Newly created node must be `dirty` just because it is new. - // This is not a default for `YGNode`. + // This is not a default for `yoga::Node`. yogaNode_.setDirty(true); if (getTraits().check(ShadowNodeTraits::Trait::MeasurableYogaNode)) { @@ -106,7 +106,7 @@ YogaLayoutableShadowNode::YogaLayoutableShadowNode( yogaConfig_(FabricDefaultYogaLog), yogaNode_(static_cast(sourceShadowNode) .yogaNode_) { - // Note, cloned `YGNode` instance (copied using copy-constructor) inherits + // Note, cloned `yoga::Node` instance (copied using copy-constructor) inherits // dirty flag, measure function, and other properties being set originally in // the `YogaLayoutableShadowNode` constructor above. @@ -321,7 +321,8 @@ bool YogaLayoutableShadowNode::doesOwn( void YogaLayoutableShadowNode::updateYogaChildrenOwnersIfNeeded() { for (auto &childYogaNode : yogaNode_.getChildren()) { if (childYogaNode->getOwner() == &yogaNode_) { - childYogaNode->setOwner(reinterpret_cast(0xBADC0FFEE0DDF00D)); + childYogaNode->setOwner( + reinterpret_cast(0xBADC0FFEE0DDF00D)); } } } @@ -336,7 +337,9 @@ void YogaLayoutableShadowNode::updateYogaChildren() { bool isClean = !yogaNode_.isDirty() && getChildren().size() == yogaNode_.getChildren().size(); - auto oldYogaChildren = isClean ? yogaNode_.getChildren() : YGVector{}; + auto oldYogaChildren = + isClean ? yogaNode_.getChildren() : std::vector{}; + yogaNode_.setChildren({}); yogaLayoutableChildren_.clear(); @@ -829,9 +832,9 @@ YGSize YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector( } YogaLayoutableShadowNode &YogaLayoutableShadowNode::shadowNodeFromContext( - YGNode *yogaNode) { + YGNodeRef yogaNode) { return traitCast( - *static_cast(yogaNode->getContext())); + *static_cast(YGNodeGetContext(yogaNode))); } yoga::Config &YogaLayoutableShadowNode::initializeYogaConfig( diff --git a/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.h b/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.h index 33b56e4e358..5caefc2d469 100644 --- a/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.h +++ b/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.h @@ -10,7 +10,7 @@ #include #include -#include +#include #include #include @@ -100,7 +100,7 @@ class YogaLayoutableShadowNode : public LayoutableShadowNode { * Yoga node as `mutable` here to avoid `static_cast`ing the pointer to this * all the time. */ - mutable YGNode yogaNode_; + mutable yoga::Node yogaNode_; private: /* @@ -156,17 +156,17 @@ class YogaLayoutableShadowNode : public LayoutableShadowNode { static yoga::Config &initializeYogaConfig( yoga::Config &config, YGConfigRef previousConfig = nullptr); - static YGNode *yogaNodeCloneCallbackConnector( - YGNode *oldYogaNode, - YGNode *parentYogaNode, + static YGNodeRef yogaNodeCloneCallbackConnector( + YGNodeRef oldYogaNode, + YGNodeRef parentYogaNode, int childIndex); static YGSize yogaNodeMeasureCallbackConnector( - YGNode *yogaNode, + YGNodeRef yogaNode, float width, YGMeasureMode widthMode, float height, YGMeasureMode heightMode); - static YogaLayoutableShadowNode &shadowNodeFromContext(YGNode *yogaNode); + static YogaLayoutableShadowNode &shadowNodeFromContext(YGNodeRef yogaNode); #pragma mark - RTL Legacy Autoflip diff --git a/packages/react-native/ReactCommon/react/renderer/components/view/YogaStylableProps.cpp b/packages/react-native/ReactCommon/react/renderer/components/view/YogaStylableProps.cpp index aa786829011..f3ce28bc98f 100644 --- a/packages/react-native/ReactCommon/react/renderer/components/view/YogaStylableProps.cpp +++ b/packages/react-native/ReactCommon/react/renderer/components/view/YogaStylableProps.cpp @@ -12,7 +12,6 @@ #include #include #include -#include #include #include "conversions.h" diff --git a/packages/react-native/ReactCommon/react/renderer/components/view/conversions.h b/packages/react-native/ReactCommon/react/renderer/components/view/conversions.h index 5bd66eea65a..c744d49a6ff 100644 --- a/packages/react-native/ReactCommon/react/renderer/components/view/conversions.h +++ b/packages/react-native/ReactCommon/react/renderer/components/view/conversions.h @@ -18,8 +18,8 @@ #include #include #include -#include #include +#include #include #include @@ -113,7 +113,7 @@ inline std::optional optionalFloatFromYogaValue( } } -inline LayoutMetrics layoutMetricsFromYogaNode(YGNode &yogaNode) { +inline LayoutMetrics layoutMetricsFromYogaNode(yoga::Node &yogaNode) { auto layoutMetrics = LayoutMetrics{}; layoutMetrics.frame = Rect{ diff --git a/packages/react-native/ReactCommon/react/renderer/core/ShadowNodeTraits.h b/packages/react-native/ReactCommon/react/renderer/core/ShadowNodeTraits.h index 9bb4d77a9cf..d3fd255326d 100644 --- a/packages/react-native/ReactCommon/react/renderer/core/ShadowNodeTraits.h +++ b/packages/react-native/ReactCommon/react/renderer/core/ShadowNodeTraits.h @@ -60,7 +60,7 @@ class ShadowNodeTraits { // Any Yoga node (not only Leaf ones) can have this trait. DirtyYogaNode = 1 << 7, - // Inherits `YogaLayoutableShadowNode` and enforces that the `YGNode` is a + // Inherits `YogaLayoutableShadowNode` and enforces that the yoga node is a // leaf. LeafYogaNode = 1 << 8, diff --git a/packages/react-native/ReactCommon/yoga/yoga/Utils.h b/packages/react-native/ReactCommon/yoga/yoga/Utils.h index 78b44de6939..bd8ab309225 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/Utils.h +++ b/packages/react-native/ReactCommon/yoga/yoga/Utils.h @@ -7,7 +7,7 @@ #pragma once -#include "YGNode.h" +#include #include #include @@ -43,7 +43,7 @@ struct YGCollectFlexItemsRowValues { float totalFlexGrowFactors; float totalFlexShrinkScaledFactors; uint32_t endOfLineIndex; - std::vector relativeChildren; + std::vector relativeChildren; float remainingFreeSpace; // The size of the mainDim for the row after considering size, padding, margin // and border of flex items. This is used to calculate maxLineDim after going diff --git a/packages/react-native/ReactCommon/yoga/yoga/YGNodePrint.cpp b/packages/react-native/ReactCommon/yoga/yoga/YGNodePrint.cpp index c1205abbdc7..d76aa26fb97 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/YGNodePrint.cpp +++ b/packages/react-native/ReactCommon/yoga/yoga/YGNodePrint.cpp @@ -12,9 +12,8 @@ #include #include "YGNodePrint.h" -#include "YGNode.h" #include -#include "Utils.h" +#include namespace facebook::yoga { typedef std::string string; @@ -92,7 +91,7 @@ static void appendEdges( const string& key, const Style::Edges& edges) { if (areFourValuesEqual(edges)) { - auto edgeValue = YGNode::computeEdgeValueForColumn( + auto edgeValue = yoga::Node::computeEdgeValueForColumn( edges, YGEdgeLeft, CompactValue::ofZero()); appendNumberIfNotZero(base, key, edgeValue); } else { @@ -110,16 +109,16 @@ static void appendEdgeIfNotUndefined( const YGEdge edge) { // TODO: this doesn't take RTL / YGEdgeStart / YGEdgeEnd into account auto value = (edge == YGEdgeLeft || edge == YGEdgeRight) - ? YGNode::computeEdgeValueForRow( + ? yoga::Node::computeEdgeValueForRow( edges, edge, edge, CompactValue::ofUndefined()) - : YGNode::computeEdgeValueForColumn( + : yoga::Node::computeEdgeValueForColumn( edges, edge, CompactValue::ofUndefined()); appendNumberIfNotUndefined(base, str, value); } void YGNodeToString( std::string& str, - YGNodeRef node, + yoga::Node* node, YGPrintOptions options, uint32_t level) { indent(str, level); @@ -141,27 +140,27 @@ void YGNodeToString( if (options & YGPrintOptionsStyle) { appendFormattedString(str, "style=\""); const auto& style = node->getStyle(); - if (style.flexDirection() != YGNode().getStyle().flexDirection()) { + if (style.flexDirection() != yoga::Node{}.getStyle().flexDirection()) { appendFormattedString( str, "flex-direction: %s; ", YGFlexDirectionToString(style.flexDirection())); } - if (style.justifyContent() != YGNode().getStyle().justifyContent()) { + if (style.justifyContent() != yoga::Node{}.getStyle().justifyContent()) { appendFormattedString( str, "justify-content: %s; ", YGJustifyToString(style.justifyContent())); } - if (style.alignItems() != YGNode().getStyle().alignItems()) { + if (style.alignItems() != yoga::Node{}.getStyle().alignItems()) { appendFormattedString( str, "align-items: %s; ", YGAlignToString(style.alignItems())); } - if (style.alignContent() != YGNode().getStyle().alignContent()) { + if (style.alignContent() != yoga::Node{}.getStyle().alignContent()) { appendFormattedString( str, "align-content: %s; ", YGAlignToString(style.alignContent())); } - if (style.alignSelf() != YGNode().getStyle().alignSelf()) { + if (style.alignSelf() != yoga::Node{}.getStyle().alignSelf()) { appendFormattedString( str, "align-self: %s; ", YGAlignToString(style.alignSelf())); } @@ -170,17 +169,17 @@ void YGNodeToString( appendNumberIfNotAuto(str, "flex-basis", style.flexBasis()); appendFloatOptionalIfDefined(str, "flex", style.flex()); - if (style.flexWrap() != YGNode().getStyle().flexWrap()) { + if (style.flexWrap() != yoga::Node{}.getStyle().flexWrap()) { appendFormattedString( str, "flex-wrap: %s; ", YGWrapToString(style.flexWrap())); } - if (style.overflow() != YGNode().getStyle().overflow()) { + if (style.overflow() != yoga::Node{}.getStyle().overflow()) { appendFormattedString( str, "overflow: %s; ", YGOverflowToString(style.overflow())); } - if (style.display() != YGNode().getStyle().display()) { + if (style.display() != yoga::Node{}.getStyle().display()) { appendFormattedString( str, "display: %s; ", YGDisplayToString(style.display())); } @@ -188,15 +187,16 @@ void YGNodeToString( appendEdges(str, "padding", style.padding()); appendEdges(str, "border", style.border()); - if (YGNode::computeColumnGap(style.gap(), CompactValue::ofUndefined()) != - YGNode::computeColumnGap( - YGNode().getStyle().gap(), CompactValue::ofUndefined())) { + if (yoga::Node::computeColumnGap( + style.gap(), CompactValue::ofUndefined()) != + yoga::Node::computeColumnGap( + yoga::Node{}.getStyle().gap(), CompactValue::ofUndefined())) { appendNumberIfNotUndefined( str, "column-gap", style.gap()[YGGutterColumn]); } - if (YGNode::computeRowGap(style.gap(), CompactValue::ofUndefined()) != - YGNode::computeRowGap( - YGNode().getStyle().gap(), CompactValue::ofUndefined())) { + if (yoga::Node::computeRowGap(style.gap(), CompactValue::ofUndefined()) != + yoga::Node::computeRowGap( + yoga::Node{}.getStyle().gap(), CompactValue::ofUndefined())) { appendNumberIfNotUndefined(str, "row-gap", style.gap()[YGGutterRow]); } @@ -211,7 +211,7 @@ void YGNodeToString( appendNumberIfNotAuto( str, "min-height", style.minDimensions()[YGDimensionHeight]); - if (style.positionType() != YGNode().getStyle().positionType()) { + if (style.positionType() != yoga::Node{}.getStyle().positionType()) { appendFormattedString( str, "position: %s; ", YGPositionTypeToString(style.positionType())); } @@ -232,7 +232,7 @@ void YGNodeToString( if (options & YGPrintOptionsChildren && childCount > 0) { for (uint32_t i = 0; i < childCount; i++) { appendFormattedString(str, "\n"); - YGNodeToString(str, YGNodeGetChild(node, i), options, level + 1); + YGNodeToString(str, node->getChild(i), options, level + 1); } appendFormattedString(str, "\n"); indent(str, level); diff --git a/packages/react-native/ReactCommon/yoga/yoga/YGNodePrint.h b/packages/react-native/ReactCommon/yoga/yoga/YGNodePrint.h index 7648f83c7bb..b991c41a7f3 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/YGNodePrint.h +++ b/packages/react-native/ReactCommon/yoga/yoga/YGNodePrint.h @@ -12,12 +12,13 @@ #include #include +#include namespace facebook::yoga { void YGNodeToString( std::string& str, - YGNodeRef node, + yoga::Node* node, YGPrintOptions options, uint32_t level); diff --git a/packages/react-native/ReactCommon/yoga/yoga/Yoga-internal.h b/packages/react-native/ReactCommon/yoga/yoga/Yoga-internal.h index d4e6df63e54..3fc4f23ac3e 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/Yoga-internal.h +++ b/packages/react-native/ReactCommon/yoga/yoga/Yoga-internal.h @@ -16,8 +16,6 @@ #include -using YGVector = std::vector; - YG_EXTERN_C_BEGIN void YGNodeCalculateLayoutWithContext( diff --git a/packages/react-native/ReactCommon/yoga/yoga/Yoga.cpp b/packages/react-native/ReactCommon/yoga/yoga/Yoga.cpp index b52ded0e089..eb84c47a407 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/Yoga.cpp +++ b/packages/react-native/ReactCommon/yoga/yoga/Yoga.cpp @@ -14,8 +14,8 @@ #include #include "log.h" -#include "Utils.h" -#include "YGNode.h" +#include +#include #include "YGNodePrint.h" #include #include "event/event.h" @@ -108,57 +108,57 @@ YOGA_EXPORT bool YGFloatIsUndefined(const float value) { } YOGA_EXPORT void* YGNodeGetContext(YGNodeRef node) { - return node->getContext(); + return static_cast(node)->getContext(); } YOGA_EXPORT void YGNodeSetContext(YGNodeRef node, void* context) { - return node->setContext(context); + return static_cast(node)->setContext(context); } YOGA_EXPORT YGConfigRef YGNodeGetConfig(YGNodeRef node) { - return node->getConfig(); + return static_cast(node)->getConfig(); } YOGA_EXPORT void YGNodeSetConfig(YGNodeRef node, YGConfigRef config) { - node->setConfig(static_cast(config)); + static_cast(node)->setConfig(static_cast(config)); } YOGA_EXPORT bool YGNodeHasMeasureFunc(YGNodeRef node) { - return node->hasMeasureFunc(); + return static_cast(node)->hasMeasureFunc(); } YOGA_EXPORT void YGNodeSetMeasureFunc( YGNodeRef node, YGMeasureFunc measureFunc) { - node->setMeasureFunc(measureFunc); + static_cast(node)->setMeasureFunc(measureFunc); } YOGA_EXPORT bool YGNodeHasBaselineFunc(YGNodeRef node) { - return node->hasBaselineFunc(); + return static_cast(node)->hasBaselineFunc(); } YOGA_EXPORT void YGNodeSetBaselineFunc( YGNodeRef node, YGBaselineFunc baselineFunc) { - node->setBaselineFunc(baselineFunc); + static_cast(node)->setBaselineFunc(baselineFunc); } YOGA_EXPORT YGDirtiedFunc YGNodeGetDirtiedFunc(YGNodeRef node) { - return node->getDirtied(); + return static_cast(node)->getDirtied(); } YOGA_EXPORT void YGNodeSetDirtiedFunc( YGNodeRef node, YGDirtiedFunc dirtiedFunc) { - node->setDirtiedFunc(dirtiedFunc); + static_cast(node)->setDirtiedFunc(dirtiedFunc); } YOGA_EXPORT void YGNodeSetPrintFunc(YGNodeRef node, YGPrintFunc printFunc) { - node->setPrintFunc(printFunc); + static_cast(node)->setPrintFunc(printFunc); } YOGA_EXPORT bool YGNodeGetHasNewLayout(YGNodeRef node) { - return node->getHasNewLayout(); + return static_cast(node)->getHasNewLayout(); } YOGA_EXPORT void YGConfigSetPrintTreeFlag(YGConfigRef config, bool enabled) { @@ -166,30 +166,30 @@ YOGA_EXPORT void YGConfigSetPrintTreeFlag(YGConfigRef config, bool enabled) { } YOGA_EXPORT void YGNodeSetHasNewLayout(YGNodeRef node, bool hasNewLayout) { - node->setHasNewLayout(hasNewLayout); + static_cast(node)->setHasNewLayout(hasNewLayout); } YOGA_EXPORT YGNodeType YGNodeGetNodeType(YGNodeRef node) { - return node->getNodeType(); + return static_cast(node)->getNodeType(); } YOGA_EXPORT void YGNodeSetNodeType(YGNodeRef node, YGNodeType nodeType) { - return node->setNodeType(nodeType); + return static_cast(node)->setNodeType(nodeType); } YOGA_EXPORT bool YGNodeIsDirty(YGNodeRef node) { - return node->isDirty(); + return static_cast(node)->isDirty(); } YOGA_EXPORT void YGNodeMarkDirtyAndPropagateToDescendants( const YGNodeRef node) { - return node->markDirtyAndPropagateDownwards(); + return static_cast(node)->markDirtyAndPropagateDownwards(); } int32_t gConfigInstanceCount = 0; YOGA_EXPORT WIN_EXPORT YGNodeRef YGNodeNewWithConfig(const YGConfigRef config) { - const YGNodeRef node = new YGNode{static_cast(config)}; + auto* node = new yoga::Node{static_cast(config)}; YGAssert(config != nullptr, "Tried to construct YGNode with null config"); YGAssertWithConfig( config, node != nullptr, "Could not allocate memory for node"); @@ -207,8 +207,9 @@ YOGA_EXPORT YGNodeRef YGNodeNew(void) { return YGNodeNewWithConfig(YGConfigGetDefault()); } -YOGA_EXPORT YGNodeRef YGNodeClone(YGNodeRef oldNode) { - YGNodeRef node = new YGNode(*oldNode); +YOGA_EXPORT YGNodeRef YGNodeClone(YGNodeRef oldNodeRef) { + auto oldNode = static_cast(oldNodeRef); + auto node = new yoga::Node(*oldNode); YGAssertWithConfig( oldNode->getConfig(), node != nullptr, @@ -218,15 +219,17 @@ YOGA_EXPORT YGNodeRef YGNodeClone(YGNodeRef oldNode) { return node; } -YOGA_EXPORT void YGNodeFree(const YGNodeRef node) { - if (YGNodeRef owner = node->getOwner()) { +YOGA_EXPORT void YGNodeFree(const YGNodeRef nodeRef) { + auto node = static_cast(nodeRef); + + if (auto owner = node->getOwner()) { owner->removeChild(node); node->setOwner(nullptr); } const uint32_t childCount = YGNodeGetChildCount(node); for (uint32_t i = 0; i < childCount; i++) { - const YGNodeRef child = YGNodeGetChild(node, i); + auto child = node->getChild(i); child->setOwner(nullptr); } @@ -235,16 +238,18 @@ YOGA_EXPORT void YGNodeFree(const YGNodeRef node) { } YOGA_EXPORT void YGNodeDeallocate(const YGNodeRef node) { - Event::publish(node, {node->getConfig()}); - delete node; + Event::publish(node, {YGNodeGetConfig(node)}); + delete static_cast(node); } YOGA_EXPORT void YGNodeFreeRecursiveWithCleanupFunc( - const YGNodeRef root, + const YGNodeRef rootRef, YGNodeCleanupFunc cleanup) { + const auto root = static_cast(rootRef); + uint32_t skipped = 0; while (YGNodeGetChildCount(root) > skipped) { - const YGNodeRef child = YGNodeGetChild(root, skipped); + const auto child = root->getChild(skipped); if (child->getOwner() != root) { // Don't free shared nodes that we don't own. skipped += 1; @@ -264,7 +269,7 @@ YOGA_EXPORT void YGNodeFreeRecursive(const YGNodeRef root) { } YOGA_EXPORT void YGNodeReset(YGNodeRef node) { - node->reset(); + static_cast(node)->reset(); } YOGA_EXPORT int32_t YGConfigGetInstanceCount(void) { @@ -287,8 +292,9 @@ YOGA_EXPORT void YGConfigFree(const YGConfigRef config) { } YOGA_EXPORT void YGNodeSetIsReferenceBaseline( - YGNodeRef node, + YGNodeRef nodeRef, bool isReferenceBaseline) { + auto node = static_cast(nodeRef); if (node->isReferenceBaseline() != isReferenceBaseline) { node->setIsReferenceBaseline(isReferenceBaseline); node->markDirtyAndPropagate(); @@ -296,13 +302,16 @@ YOGA_EXPORT void YGNodeSetIsReferenceBaseline( } YOGA_EXPORT bool YGNodeIsReferenceBaseline(YGNodeRef node) { - return node->isReferenceBaseline(); + return static_cast(node)->isReferenceBaseline(); } YOGA_EXPORT void YGNodeInsertChild( - const YGNodeRef owner, - const YGNodeRef child, + const YGNodeRef ownerRef, + const YGNodeRef childRef, const uint32_t index) { + auto owner = static_cast(ownerRef); + auto child = static_cast(childRef); + YGAssertWithNode( owner, child->getOwner() == nullptr, @@ -319,16 +328,22 @@ YOGA_EXPORT void YGNodeInsertChild( } YOGA_EXPORT void YGNodeSwapChild( - const YGNodeRef owner, - const YGNodeRef child, + const YGNodeRef ownerRef, + const YGNodeRef childRef, const uint32_t index) { + auto owner = static_cast(ownerRef); + auto child = static_cast(childRef); + owner->replaceChild(child, index); child->setOwner(owner); } YOGA_EXPORT void YGNodeRemoveChild( - const YGNodeRef owner, - const YGNodeRef excludedChild) { + const YGNodeRef ownerRef, + const YGNodeRef excludedChildRef) { + auto owner = static_cast(ownerRef); + auto excludedChild = static_cast(excludedChildRef); + if (YGNodeGetChildCount(owner) == 0) { // This is an empty set. Nothing to remove. return; @@ -347,19 +362,21 @@ YOGA_EXPORT void YGNodeRemoveChild( } } -YOGA_EXPORT void YGNodeRemoveAllChildren(const YGNodeRef owner) { +YOGA_EXPORT void YGNodeRemoveAllChildren(const YGNodeRef ownerRef) { + auto owner = static_cast(ownerRef); + const uint32_t childCount = YGNodeGetChildCount(owner); if (childCount == 0) { // This is an empty set already. Nothing to do. return; } - const YGNodeRef firstChild = YGNodeGetChild(owner, 0); + auto* firstChild = owner->getChild(0); if (firstChild->getOwner() == owner) { // If the first child has this node as its owner, we assume that this child // set is unique. for (uint32_t i = 0; i < childCount; i++) { - const YGNodeRef oldChild = YGNodeGetChild(owner, i); - oldChild->setLayout(YGNode().getLayout()); // layout is no longer valid + yoga::Node* oldChild = owner->getChild(i); + oldChild->setLayout({}); // layout is no longer valid oldChild->setOwner(nullptr); } owner->clearChildren(); @@ -368,42 +385,45 @@ YOGA_EXPORT void YGNodeRemoveAllChildren(const YGNodeRef owner) { } // Otherwise, we are not the owner of the child set. We don't have to do // anything to clear it. - owner->setChildren(YGVector()); + owner->setChildren({}); owner->markDirtyAndPropagate(); } YOGA_EXPORT void YGNodeSetChildren( - const YGNodeRef owner, - const YGNodeRef* children, + const YGNodeRef ownerRef, + const YGNodeRef* childrenRefs, const uint32_t count) { + auto owner = static_cast(ownerRef); + auto children = reinterpret_cast(childrenRefs); + if (!owner) { return; } - const YGVector childrenVector = {children, children + count}; + const std::vector childrenVector = {children, children + count}; if (childrenVector.size() == 0) { if (YGNodeGetChildCount(owner) > 0) { - for (YGNodeRef const child : owner->getChildren()) { - child->setLayout(YGLayout()); + for (auto* child : owner->getChildren()) { + child->setLayout({}); child->setOwner(nullptr); } - owner->setChildren(YGVector()); + owner->setChildren({}); owner->markDirtyAndPropagate(); } } else { if (YGNodeGetChildCount(owner) > 0) { - for (YGNodeRef const oldChild : owner->getChildren()) { + for (auto* oldChild : owner->getChildren()) { // Our new children may have nodes in common with the old children. We // don't reset these common nodes. if (std::find(childrenVector.begin(), childrenVector.end(), oldChild) == childrenVector.end()) { - oldChild->setLayout(YGLayout()); + oldChild->setLayout({}); oldChild->setOwner(nullptr); } } } owner->setChildren(childrenVector); - for (YGNodeRef child : childrenVector) { + for (yoga::Node* child : childrenVector) { child->setOwner(owner); } owner->markDirtyAndPropagate(); @@ -411,26 +431,31 @@ YOGA_EXPORT void YGNodeSetChildren( } YOGA_EXPORT YGNodeRef -YGNodeGetChild(const YGNodeRef node, const uint32_t index) { +YGNodeGetChild(const YGNodeRef nodeRef, const uint32_t index) { + auto node = static_cast(nodeRef); + if (index < node->getChildren().size()) { return node->getChild(index); } return nullptr; } -YOGA_EXPORT uint32_t YGNodeGetChildCount(const YGNodeRef node) { - return static_cast(node->getChildren().size()); +YOGA_EXPORT uint32_t YGNodeGetChildCount(const YGNodeConstRef node) { + return static_cast( + static_cast(node)->getChildren().size()); } YOGA_EXPORT YGNodeRef YGNodeGetOwner(const YGNodeRef node) { - return node->getOwner(); + return static_cast(node)->getOwner(); } YOGA_EXPORT YGNodeRef YGNodeGetParent(const YGNodeRef node) { - return node->getOwner(); + return static_cast(node)->getOwner(); } -YOGA_EXPORT void YGNodeMarkDirty(const YGNodeRef node) { +YOGA_EXPORT void YGNodeMarkDirty(const YGNodeRef nodeRef) { + auto node = static_cast(nodeRef); + YGAssertWithNode( node, node->hasMeasureFunc(), @@ -441,21 +466,26 @@ YOGA_EXPORT void YGNodeMarkDirty(const YGNodeRef node) { } YOGA_EXPORT void YGNodeCopyStyle( - const YGNodeRef dstNode, - const YGNodeRef srcNode) { + const YGNodeRef dstNodeRef, + const YGNodeRef srcNodeRef) { + auto dstNode = static_cast(dstNodeRef); + auto srcNode = static_cast(srcNodeRef); + if (!(dstNode->getStyle() == srcNode->getStyle())) { dstNode->setStyle(srcNode->getStyle()); dstNode->markDirtyAndPropagate(); } } -YOGA_EXPORT float YGNodeStyleGetFlexGrow(const YGNodeConstRef node) { +YOGA_EXPORT float YGNodeStyleGetFlexGrow(const YGNodeConstRef nodeRef) { + auto node = static_cast(nodeRef); return node->getStyle().flexGrow().isUndefined() ? kDefaultFlexGrow : node->getStyle().flexGrow().unwrap(); } -YOGA_EXPORT float YGNodeStyleGetFlexShrink(const YGNodeConstRef node) { +YOGA_EXPORT float YGNodeStyleGetFlexShrink(const YGNodeConstRef nodeRef) { + auto node = static_cast(nodeRef); return node->getStyle().flexShrink().isUndefined() ? (node->getConfig()->useWebDefaults() ? kWebDefaultFlexShrink : kDefaultFlexShrink) @@ -466,7 +496,7 @@ namespace { template void updateStyle( - YGNode* node, + yoga::Node* node, T value, NeedsUpdate&& needsUpdate, Update&& update) { @@ -477,9 +507,9 @@ void updateStyle( } template -void updateStyle(YGNode* node, Ref (Style::*prop)(), T value) { +void updateStyle(YGNodeRef node, Ref (Style::*prop)(), T value) { updateStyle( - node, + static_cast(node), value, [prop](Style& s, T x) { return (s.*prop)() != x; }, [prop](Style& s, T x) { (s.*prop)() = x; }); @@ -487,12 +517,12 @@ void updateStyle(YGNode* node, Ref (Style::*prop)(), T value) { template void updateIndexedStyleProp( - YGNode* node, + YGNodeRef node, Ref (Style::*prop)(), Idx idx, CompactValue value) { updateStyle( - node, + static_cast(node), value, [idx, prop](Style& s, CompactValue x) { return (s.*prop)()[idx] != x; }, [idx, prop](Style& s, CompactValue x) { (s.*prop)()[idx] = x; }); @@ -513,7 +543,7 @@ YOGA_EXPORT void YGNodeStyleSetDirection( updateStyle(node, &Style::direction, value); } YOGA_EXPORT YGDirection YGNodeStyleGetDirection(const YGNodeConstRef node) { - return node->getStyle().direction(); + return static_cast(node)->getStyle().direction(); } YOGA_EXPORT void YGNodeStyleSetFlexDirection( @@ -524,7 +554,7 @@ YOGA_EXPORT void YGNodeStyleSetFlexDirection( } YOGA_EXPORT YGFlexDirection YGNodeStyleGetFlexDirection(const YGNodeConstRef node) { - return node->getStyle().flexDirection(); + return static_cast(node)->getStyle().flexDirection(); } YOGA_EXPORT void YGNodeStyleSetJustifyContent( @@ -534,7 +564,7 @@ YOGA_EXPORT void YGNodeStyleSetJustifyContent( node, &Style::justifyContent, justifyContent); } YOGA_EXPORT YGJustify YGNodeStyleGetJustifyContent(const YGNodeConstRef node) { - return node->getStyle().justifyContent(); + return static_cast(node)->getStyle().justifyContent(); } YOGA_EXPORT void YGNodeStyleSetAlignContent( @@ -544,7 +574,7 @@ YOGA_EXPORT void YGNodeStyleSetAlignContent( node, &Style::alignContent, alignContent); } YOGA_EXPORT YGAlign YGNodeStyleGetAlignContent(const YGNodeConstRef node) { - return node->getStyle().alignContent(); + return static_cast(node)->getStyle().alignContent(); } YOGA_EXPORT void YGNodeStyleSetAlignItems( @@ -553,7 +583,7 @@ YOGA_EXPORT void YGNodeStyleSetAlignItems( updateStyle(node, &Style::alignItems, alignItems); } YOGA_EXPORT YGAlign YGNodeStyleGetAlignItems(const YGNodeConstRef node) { - return node->getStyle().alignItems(); + return static_cast(node)->getStyle().alignItems(); } YOGA_EXPORT void YGNodeStyleSetAlignSelf( @@ -562,7 +592,7 @@ YOGA_EXPORT void YGNodeStyleSetAlignSelf( updateStyle(node, &Style::alignSelf, alignSelf); } YOGA_EXPORT YGAlign YGNodeStyleGetAlignSelf(const YGNodeConstRef node) { - return node->getStyle().alignSelf(); + return static_cast(node)->getStyle().alignSelf(); } YOGA_EXPORT void YGNodeStyleSetPositionType( @@ -573,7 +603,7 @@ YOGA_EXPORT void YGNodeStyleSetPositionType( } YOGA_EXPORT YGPositionType YGNodeStyleGetPositionType(const YGNodeConstRef node) { - return node->getStyle().positionType(); + return static_cast(node)->getStyle().positionType(); } YOGA_EXPORT void YGNodeStyleSetFlexWrap( @@ -582,7 +612,7 @@ YOGA_EXPORT void YGNodeStyleSetFlexWrap( updateStyle(node, &Style::flexWrap, flexWrap); } YOGA_EXPORT YGWrap YGNodeStyleGetFlexWrap(const YGNodeConstRef node) { - return node->getStyle().flexWrap(); + return static_cast(node)->getStyle().flexWrap(); } YOGA_EXPORT void YGNodeStyleSetOverflow( @@ -591,7 +621,7 @@ YOGA_EXPORT void YGNodeStyleSetOverflow( updateStyle(node, &Style::overflow, overflow); } YOGA_EXPORT YGOverflow YGNodeStyleGetOverflow(const YGNodeConstRef node) { - return node->getStyle().overflow(); + return static_cast(node)->getStyle().overflow(); } YOGA_EXPORT void YGNodeStyleSetDisplay( @@ -600,7 +630,7 @@ YOGA_EXPORT void YGNodeStyleSetDisplay( updateStyle(node, &Style::display, display); } YOGA_EXPORT YGDisplay YGNodeStyleGetDisplay(const YGNodeConstRef node) { - return node->getStyle().display(); + return static_cast(node)->getStyle().display(); } // TODO(T26792433): Change the API to accept YGFloatOptional. @@ -609,7 +639,8 @@ YOGA_EXPORT void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) { } // TODO(T26792433): Change the API to accept YGFloatOptional. -YOGA_EXPORT float YGNodeStyleGetFlex(const YGNodeConstRef node) { +YOGA_EXPORT float YGNodeStyleGetFlex(const YGNodeConstRef nodeRef) { + auto node = static_cast(nodeRef); return node->getStyle().flex().isUndefined() ? YGUndefined : node->getStyle().flex().unwrap(); @@ -632,7 +663,8 @@ YOGA_EXPORT void YGNodeStyleSetFlexShrink( } YOGA_EXPORT YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) { - YGValue flexBasis = node->getStyle().flexBasis(); + YGValue flexBasis = + static_cast(node)->getStyle().flexBasis(); if (flexBasis.unit == YGUnitUndefined || flexBasis.unit == YGUnitAuto) { // TODO(T26792433): Get rid off the use of YGUndefined at client side flexBasis.value = YGUndefined; @@ -676,7 +708,7 @@ YOGA_EXPORT void YGNodeStyleSetPositionPercent( node, &Style::position, edge, value); } YOGA_EXPORT YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) { - return node->getStyle().position()[edge]; + return static_cast(node)->getStyle().position()[edge]; } YOGA_EXPORT void YGNodeStyleSetMargin( @@ -698,7 +730,7 @@ YOGA_EXPORT void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge) { node, &Style::margin, edge, CompactValue::ofAuto()); } YOGA_EXPORT YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge) { - return node->getStyle().margin()[edge]; + return static_cast(node)->getStyle().margin()[edge]; } YOGA_EXPORT void YGNodeStyleSetPadding( @@ -718,7 +750,7 @@ YOGA_EXPORT void YGNodeStyleSetPaddingPercent( node, &Style::padding, edge, value); } YOGA_EXPORT YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge) { - return node->getStyle().padding()[edge]; + return static_cast(node)->getStyle().padding()[edge]; } // TODO(T26792433): Change the API to accept YGFloatOptional. @@ -733,7 +765,7 @@ YOGA_EXPORT void YGNodeStyleSetBorder( YOGA_EXPORT float YGNodeStyleGetBorder( const YGNodeConstRef node, const YGEdge edge) { - auto border = node->getStyle().border()[edge]; + auto border = static_cast(node)->getStyle().border()[edge]; if (border.isUndefined() || border.isAuto()) { // TODO(T26792433): Rather than returning YGUndefined, change the api to // return YGFloatOptional. @@ -754,7 +786,8 @@ YOGA_EXPORT void YGNodeStyleSetGap( YOGA_EXPORT float YGNodeStyleGetGap( const YGNodeConstRef node, const YGGutter gutter) { - auto gapLength = node->getStyle().gap()[gutter]; + auto gapLength = + static_cast(node)->getStyle().gap()[gutter]; if (gapLength.isUndefined() || gapLength.isAuto()) { // TODO(T26792433): Rather than returning YGUndefined, change the api to // return YGFloatOptional. @@ -768,7 +801,8 @@ YOGA_EXPORT float YGNodeStyleGetGap( // TODO(T26792433): Change the API to accept YGFloatOptional. YOGA_EXPORT float YGNodeStyleGetAspectRatio(const YGNodeConstRef node) { - const YGFloatOptional op = node->getStyle().aspectRatio(); + const YGFloatOptional op = + static_cast(node)->getStyle().aspectRatio(); return op.isUndefined() ? YGUndefined : op.unwrap(); } @@ -795,7 +829,9 @@ YOGA_EXPORT void YGNodeStyleSetWidthAuto(YGNodeRef node) { node, &Style::dimensions, YGDimensionWidth, CompactValue::ofAuto()); } YOGA_EXPORT YGValue YGNodeStyleGetWidth(YGNodeConstRef node) { - return node->getStyle().dimensions()[YGDimensionWidth]; + return static_cast(node) + ->getStyle() + .dimensions()[YGDimensionWidth]; } YOGA_EXPORT void YGNodeStyleSetHeight(YGNodeRef node, float points) { @@ -813,7 +849,9 @@ YOGA_EXPORT void YGNodeStyleSetHeightAuto(YGNodeRef node) { node, &Style::dimensions, YGDimensionHeight, CompactValue::ofAuto()); } YOGA_EXPORT YGValue YGNodeStyleGetHeight(YGNodeConstRef node) { - return node->getStyle().dimensions()[YGDimensionHeight]; + return static_cast(node) + ->getStyle() + .dimensions()[YGDimensionHeight]; } YOGA_EXPORT void YGNodeStyleSetMinWidth( @@ -831,7 +869,9 @@ YOGA_EXPORT void YGNodeStyleSetMinWidthPercent( node, &Style::minDimensions, YGDimensionWidth, value); } YOGA_EXPORT YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) { - return node->getStyle().minDimensions()[YGDimensionWidth]; + return static_cast(node) + ->getStyle() + .minDimensions()[YGDimensionWidth]; } YOGA_EXPORT void YGNodeStyleSetMinHeight( @@ -849,7 +889,9 @@ YOGA_EXPORT void YGNodeStyleSetMinHeightPercent( node, &Style::minDimensions, YGDimensionHeight, value); } YOGA_EXPORT YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) { - return node->getStyle().minDimensions()[YGDimensionHeight]; + return static_cast(node) + ->getStyle() + .minDimensions()[YGDimensionHeight]; } YOGA_EXPORT void YGNodeStyleSetMaxWidth( @@ -867,7 +909,9 @@ YOGA_EXPORT void YGNodeStyleSetMaxWidthPercent( node, &Style::maxDimensions, YGDimensionWidth, value); } YOGA_EXPORT YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) { - return node->getStyle().maxDimensions()[YGDimensionWidth]; + return static_cast(node) + ->getStyle() + .maxDimensions()[YGDimensionWidth]; } YOGA_EXPORT void YGNodeStyleSetMaxHeight( @@ -885,17 +929,20 @@ YOGA_EXPORT void YGNodeStyleSetMaxHeightPercent( node, &Style::maxDimensions, YGDimensionHeight, value); } YOGA_EXPORT YGValue YGNodeStyleGetMaxHeight(const YGNodeConstRef node) { - return node->getStyle().maxDimensions()[YGDimensionHeight]; + return static_cast(node) + ->getStyle() + .maxDimensions()[YGDimensionHeight]; } -#define YG_NODE_LAYOUT_PROPERTY_IMPL(type, name, instanceName) \ - YOGA_EXPORT type YGNodeLayoutGet##name(const YGNodeRef node) { \ - return node->getLayout().instanceName; \ +#define YG_NODE_LAYOUT_PROPERTY_IMPL(type, name, instanceName) \ + YOGA_EXPORT type YGNodeLayoutGet##name(const YGNodeRef node) { \ + return static_cast(node)->getLayout().instanceName; \ } #define YG_NODE_LAYOUT_RESOLVED_PROPERTY_IMPL(type, name, instanceName) \ YOGA_EXPORT type YGNodeLayoutGet##name( \ - const YGNodeRef node, const YGEdge edge) { \ + const YGNodeRef nodeRef, const YGEdge edge) { \ + auto node = static_cast(nodeRef); \ YGAssertWithNode( \ node, \ edge <= YGEdgeEnd, \ @@ -936,7 +983,7 @@ YG_NODE_LAYOUT_RESOLVED_PROPERTY_IMPL(float, Padding, padding) std::atomic gCurrentGenerationCount(0); bool YGLayoutNodeInternal( - const YGNodeRef node, + yoga::Node* const node, const float availableWidth, const float availableHeight, const YGDirection ownerDirection, @@ -953,19 +1000,14 @@ bool YGLayoutNodeInternal( const uint32_t generationCount); #ifdef DEBUG -static void YGNodePrintInternal( - const YGNodeRef node, +YOGA_EXPORT void YGNodePrint( + const YGNodeRef nodeRef, const YGPrintOptions options) { + const auto node = static_cast(nodeRef); std::string str; facebook::yoga::YGNodeToString(str, node, options, 0); Log::log(node, YGLogLevelDebug, nullptr, str.c_str()); } - -YOGA_EXPORT void YGNodePrint( - const YGNodeRef node, - const YGPrintOptions options) { - YGNodePrintInternal(node, options); -} #endif const std::array leading = { @@ -984,7 +1026,7 @@ static const std::array dim = { {YGDimensionHeight, YGDimensionHeight, YGDimensionWidth, YGDimensionWidth}}; static inline float YGNodePaddingAndBorderForAxis( - const YGNodeConstRef node, + const yoga::Node* const node, const YGFlexDirection axis, const float widthSize) { return (node->getLeadingPaddingAndBorder(axis, widthSize) + @@ -992,7 +1034,9 @@ static inline float YGNodePaddingAndBorderForAxis( .unwrap(); } -static inline YGAlign YGNodeAlignItem(const YGNode* node, const YGNode* child) { +static inline YGAlign YGNodeAlignItem( + const yoga::Node* node, + const yoga::Node* child) { const YGAlign align = child->getStyle().alignSelf() == YGAlignAuto ? node->getStyle().alignItems() : child->getStyle().alignSelf(); @@ -1003,7 +1047,7 @@ static inline YGAlign YGNodeAlignItem(const YGNode* node, const YGNode* child) { return align; } -static float YGBaseline(const YGNodeRef node, void* layoutContext) { +static float YGBaseline(yoga::Node* node, void* layoutContext) { if (node->hasBaselineFunc()) { Event::publish(node); @@ -1022,10 +1066,10 @@ static float YGBaseline(const YGNodeRef node, void* layoutContext) { return baseline; } - YGNodeRef baselineChild = nullptr; + yoga::Node* baselineChild = nullptr; const uint32_t childCount = YGNodeGetChildCount(node); for (uint32_t i = 0; i < childCount; i++) { - const YGNodeRef child = YGNodeGetChild(node, i); + auto child = node->getChild(i); if (child->getLineIndex() > 0) { break; } @@ -1051,7 +1095,7 @@ static float YGBaseline(const YGNodeRef node, void* layoutContext) { return baseline + baselineChild->getLayout().position[YGEdgeTop]; } -static bool YGIsBaselineLayout(const YGNodeRef node) { +static bool YGIsBaselineLayout(const yoga::Node* node) { if (YGFlexDirectionIsColumn(node->getStyle().flexDirection())) { return false; } @@ -1060,7 +1104,7 @@ static bool YGIsBaselineLayout(const YGNodeRef node) { } const uint32_t childCount = YGNodeGetChildCount(node); for (uint32_t i = 0; i < childCount; i++) { - const YGNodeRef child = YGNodeGetChild(node, i); + auto child = node->getChild(i); if (child->getStyle().positionType() != YGPositionTypeAbsolute && child->getStyle().alignSelf() == YGAlignBaseline) { return true; @@ -1071,7 +1115,7 @@ static bool YGIsBaselineLayout(const YGNodeRef node) { } static inline float YGNodeDimWithMargin( - const YGNodeRef node, + const yoga::Node* const node, const YGFlexDirection axis, const float widthSize) { return node->getLayout().measuredDimensions[dim[axis]] + @@ -1081,7 +1125,7 @@ static inline float YGNodeDimWithMargin( } static inline bool YGNodeIsStyleDimDefined( - const YGNodeRef node, + const yoga::Node* const node, const YGFlexDirection axis, const float ownerSize) { bool isUndefined = @@ -1098,14 +1142,14 @@ static inline bool YGNodeIsStyleDimDefined( } static inline bool YGNodeIsLayoutDimDefined( - const YGNodeRef node, + const yoga::Node* const node, const YGFlexDirection axis) { const float value = node->getLayout().measuredDimensions[dim[axis]]; return !YGFloatIsUndefined(value) && value >= 0.0f; } static YGFloatOptional YGNodeBoundAxisWithinMinAndMax( - const YGNodeConstRef node, + const yoga::Node* const node, const YGFlexDirection axis, const YGFloatOptional value, const float axisSize) { @@ -1138,7 +1182,7 @@ static YGFloatOptional YGNodeBoundAxisWithinMinAndMax( // Like YGNodeBoundAxisWithinMinAndMax but also ensures that the value doesn't // go below the padding and border amount. static inline float YGNodeBoundAxis( - const YGNodeRef node, + const yoga::Node* const node, const YGFlexDirection axis, const float value, const float axisSize, @@ -1151,8 +1195,8 @@ static inline float YGNodeBoundAxis( } static void YGNodeSetChildTrailingPosition( - const YGNodeRef node, - const YGNodeRef child, + const yoga::Node* const node, + yoga::Node* const child, const YGFlexDirection axis) { const float size = child->getLayout().measuredDimensions[dim[axis]]; child->setLayoutPosition( @@ -1162,7 +1206,7 @@ static void YGNodeSetChildTrailingPosition( } static void YGConstrainMaxSizeForMode( - const YGNodeConstRef node, + const yoga::Node* const node, const enum YGFlexDirection axis, const float ownerAxisSize, const float ownerWidth, @@ -1189,8 +1233,8 @@ static void YGConstrainMaxSizeForMode( } static void YGNodeComputeFlexBasisForChild( - const YGNodeRef node, - const YGNodeRef child, + const yoga::Node* const node, + yoga::Node* const child, const float width, const YGMeasureMode widthMode, const float height, @@ -1388,8 +1432,8 @@ static void YGNodeComputeFlexBasisForChild( } static void YGNodeAbsoluteLayoutChild( - const YGNodeRef node, - const YGNodeRef child, + const yoga::Node* const node, + yoga::Node* const child, const float width, const YGMeasureMode widthMode, const float height, @@ -1622,7 +1666,7 @@ static void YGNodeAbsoluteLayoutChild( } static void YGNodeWithMeasureFuncSetMeasuredDimensions( - const YGNodeRef node, + yoga::Node* const node, float availableWidth, float availableHeight, const YGMeasureMode widthMeasureMode, @@ -1729,7 +1773,7 @@ static void YGNodeWithMeasureFuncSetMeasuredDimensions( // For nodes with no children, use the available values if they were provided, // or the minimum size as indicated by the padding and border sizes. static void YGNodeEmptyContainerSetMeasuredDimensions( - const YGNodeRef node, + yoga::Node* const node, const float availableWidth, const float availableHeight, const YGMeasureMode widthMeasureMode, @@ -1762,7 +1806,7 @@ static void YGNodeEmptyContainerSetMeasuredDimensions( } static bool YGNodeFixedSizeSetMeasuredDimensions( - const YGNodeRef node, + yoga::Node* const node, const float availableWidth, const float availableHeight, const YGMeasureMode widthMeasureMode, @@ -1807,7 +1851,7 @@ static bool YGNodeFixedSizeSetMeasuredDimensions( } static void YGZeroOutLayoutRecursively( - const YGNodeRef node, + yoga::Node* const node, void* layoutContext) { node->getLayout() = {}; node->setLayoutDimension(0, 0); @@ -1819,7 +1863,7 @@ static void YGZeroOutLayoutRecursively( } static float YGNodeCalculateAvailableInnerDim( - const YGNodeConstRef node, + const yoga::Node* const node, const YGDimension dimension, const float availableDim, const float paddingAndBorder, @@ -1850,7 +1894,7 @@ static float YGNodeCalculateAvailableInnerDim( } static float YGNodeComputeFlexBasisForChildren( - const YGNodeRef node, + yoga::Node* const node, const float availableInnerWidth, const float availableInnerHeight, YGMeasureMode widthMeasureMode, @@ -1865,7 +1909,7 @@ static float YGNodeComputeFlexBasisForChildren( const uint32_t generationCount) { float totalOuterFlexBasis = 0.0f; YGNodeRef singleFlexChild = nullptr; - const YGVector& children = node->getChildren(); + const auto& children = node->getChildren(); YGMeasureMode measureModeMainDim = YGFlexDirectionIsRow(mainAxis) ? widthMeasureMode : heightMeasureMode; // If there is only one child with flexGrow + flexShrink it means we can set @@ -1947,7 +1991,7 @@ static float YGNodeComputeFlexBasisForChildren( // YGNodeComputeFlexBasisForChildren function). This function calculates // YGCollectFlexItemsRowMeasurement static YGCollectFlexItemsRowValues YGCalculateCollectFlexItemsRowValues( - const YGNodeRef& node, + yoga::Node* const node, const YGDirection ownerDirection, const float mainAxisownerSize, const float availableInnerWidth, @@ -1966,7 +2010,7 @@ static YGCollectFlexItemsRowValues YGCalculateCollectFlexItemsRowValues( // Add items to the current line until it's full or we run out of items. uint32_t endOfLineIndex = startOfLineIndex; for (; endOfLineIndex < node->getChildren().size(); endOfLineIndex++) { - const YGNodeRef child = node->getChild(endOfLineIndex); + auto child = node->getChild(endOfLineIndex); if (child->getStyle().display() == YGDisplayNone || child->getStyle().positionType() == YGPositionTypeAbsolute) { continue; @@ -2039,7 +2083,7 @@ static YGCollectFlexItemsRowValues YGCalculateCollectFlexItemsRowValues( // please ensure that YGDistributeFreeSpaceFirstPass is called. static float YGDistributeFreeSpaceSecondPass( YGCollectFlexItemsRowValues& collectedFlexItemsValues, - const YGNodeRef node, + yoga::Node* const node, const YGFlexDirection mainAxis, const YGFlexDirection crossAxis, const float mainAxisownerSize, @@ -2342,7 +2386,7 @@ static void YGDistributeFreeSpaceFirstPass( // assigned to them. // static void YGResolveFlexibleLength( - const YGNodeRef node, + yoga::Node* const node, YGCollectFlexItemsRowValues& collectedFlexItemsValues, const YGFlexDirection mainAxis, const YGFlexDirection crossAxis, @@ -2393,7 +2437,7 @@ static void YGResolveFlexibleLength( } static void YGJustifyMainAxis( - const YGNodeRef node, + yoga::Node* const node, YGCollectFlexItemsRowValues& collectedFlexItemsValues, const uint32_t startOfLineIndex, const YGFlexDirection mainAxis, @@ -2445,7 +2489,7 @@ static void YGJustifyMainAxis( for (uint32_t i = startOfLineIndex; i < collectedFlexItemsValues.endOfLineIndex; i++) { - const YGNodeRef child = node->getChild(i); + auto child = node->getChild(i); if (child->getStyle().positionType() != YGPositionTypeAbsolute) { if (child->marginLeadingValue(mainAxis).unit == YGUnitAuto) { numberOfAutoMarginsOnCurrentLine++; @@ -2505,9 +2549,9 @@ static void YGJustifyMainAxis( for (uint32_t i = startOfLineIndex; i < collectedFlexItemsValues.endOfLineIndex; i++) { - const YGNodeRef child = node->getChild(i); + const auto child = node->getChild(i); const Style& childStyle = child->getStyle(); - const YGLayout childLayout = child->getLayout(); + const LayoutResults& childLayout = child->getLayout(); const bool isLastChild = i == collectedFlexItemsValues.endOfLineIndex - 1; // remove the gap if it is the last element of the line if (isLastChild) { @@ -2679,7 +2723,7 @@ static void YGJustifyMainAxis( // mode of YGMeasureModeUndefined in that dimension. // static void YGNodelayoutImpl( - const YGNodeRef node, + yoga::Node* const node, const float availableWidth, const float availableHeight, const YGDirection ownerDirection, @@ -3077,7 +3121,7 @@ static void YGNodelayoutImpl( // We can skip child alignment if we're just measuring the container. if (performLayout) { for (uint32_t i = startOfLineIndex; i < endOfLineIndex; i++) { - const YGNodeRef child = node->getChild(i); + const auto child = node->getChild(i); if (child->getStyle().display() == YGDisplayNone) { continue; } @@ -3279,7 +3323,7 @@ static void YGNodelayoutImpl( float maxAscentForCurrentLine = 0; float maxDescentForCurrentLine = 0; for (ii = startIndex; ii < childCount; ii++) { - const YGNodeRef child = node->getChild(ii); + const auto child = node->getChild(ii); if (child->getStyle().display() == YGDisplayNone) { continue; } @@ -3322,7 +3366,7 @@ static void YGNodelayoutImpl( if (performLayout) { for (ii = startIndex; ii < endIndex; ii++) { - const YGNodeRef child = node->getChild(ii); + const auto child = node->getChild(ii); if (child->getStyle().display() == YGDisplayNone) { continue; } @@ -3516,7 +3560,7 @@ static void YGNodelayoutImpl( // positions on wrap-reverse. if (performLayout && node->getStyle().flexWrap() == YGWrapWrapReverse) { for (uint32_t i = 0; i < childCount; i++) { - const YGNodeRef child = YGNodeGetChild(node, i); + const auto child = node->getChild(i); if (child->getStyle().positionType() != YGPositionTypeAbsolute) { child->setLayoutPosition( node->getLayout().measuredDimensions[dim[crossAxis]] - @@ -3565,7 +3609,7 @@ static void YGNodelayoutImpl( // Set trailing position if necessary. if (needsMainTrailingPos || needsCrossTrailingPos) { for (uint32_t i = 0; i < childCount; i++) { - const YGNodeRef child = node->getChild(i); + const auto child = node->getChild(i); if (child->getStyle().display() == YGDisplayNone) { continue; } @@ -3776,7 +3820,7 @@ YOGA_EXPORT bool YGNodeCanUseCachedMeasurement( // Return parameter is true if layout was performed, false if skipped // bool YGLayoutNodeInternal( - const YGNodeRef node, + yoga::Node* const node, const float availableWidth, const float availableHeight, const YGDirection ownerDirection, @@ -3791,7 +3835,7 @@ bool YGLayoutNodeInternal( void* const layoutContext, uint32_t depth, const uint32_t generationCount) { - YGLayout* layout = &node->getLayout(); + LayoutResults* layout = &node->getLayout(); depth++; @@ -4065,7 +4109,7 @@ YOGA_EXPORT float YGConfigGetPointScaleFactor(const YGConfigRef config) { } static void YGRoundToPixelGrid( - const YGNodeRef node, + yoga::Node* const node, const double pointScaleFactor, const double absoluteLeft, const double absoluteTop) { @@ -4130,23 +4174,21 @@ static void YGRoundToPixelGrid( const uint32_t childCount = YGNodeGetChildCount(node); for (uint32_t i = 0; i < childCount; i++) { YGRoundToPixelGrid( - YGNodeGetChild(node, i), - pointScaleFactor, - absoluteNodeLeft, - absoluteNodeTop); + node->getChild(i), pointScaleFactor, absoluteNodeLeft, absoluteNodeTop); } } YOGA_EXPORT void YGNodeCalculateLayoutWithContext( - const YGNodeRef node, + const YGNodeRef nodeRef, const float ownerWidth, const float ownerHeight, const YGDirection ownerDirection, void* layoutContext) { - - Event::publish(node, {layoutContext}); + Event::publish(nodeRef, {layoutContext}); LayoutData markerData = {}; + const auto node = static_cast(nodeRef); + // Increment the generation count. This will force the recursive routine to // visit all dirty nodes at least once. Subsequent visits will be skipped if // the input parameters don't change. @@ -4248,7 +4290,12 @@ YOGA_EXPORT void YGConfigSetLogger(const YGConfigRef config, YGLogger logger) { void YGAssert(const bool condition, const char* message) { if (!condition) { - Log::log(YGNodeRef{nullptr}, YGLogLevelFatal, nullptr, "%s\n", message); + Log::log( + static_cast(nullptr), + YGLogLevelFatal, + nullptr, + "%s\n", + message); throwLogicalErrorWithMessage(message); } } @@ -4258,7 +4305,12 @@ void YGAssertWithNode( const bool condition, const char* message) { if (!condition) { - Log::log(node, YGLogLevelFatal, nullptr, "%s\n", message); + Log::log( + static_cast(node), + YGLogLevelFatal, + nullptr, + "%s\n", + message); throwLogicalErrorWithMessage(message); } } diff --git a/packages/react-native/ReactCommon/yoga/yoga/Yoga.h b/packages/react-native/ReactCommon/yoga/yoga/Yoga.h index e8bf0afffd2..0c8986896c8 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/Yoga.h +++ b/packages/react-native/ReactCommon/yoga/yoga/Yoga.h @@ -79,7 +79,7 @@ WIN_EXPORT void YGNodeRemoveAllChildren(YGNodeRef node); WIN_EXPORT YGNodeRef YGNodeGetChild(YGNodeRef node, uint32_t index); WIN_EXPORT YGNodeRef YGNodeGetOwner(YGNodeRef node); WIN_EXPORT YGNodeRef YGNodeGetParent(YGNodeRef node); -WIN_EXPORT uint32_t YGNodeGetChildCount(YGNodeRef node); +WIN_EXPORT uint32_t YGNodeGetChildCount(YGNodeConstRef node); WIN_EXPORT void YGNodeSetChildren( YGNodeRef owner, const YGNodeRef* children, diff --git a/packages/react-native/ReactCommon/yoga/yoga/event/event.cpp b/packages/react-native/ReactCommon/yoga/yoga/event/event.cpp index ee47331d85a..b47e1fab7fd 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/event/event.cpp +++ b/packages/react-native/ReactCommon/yoga/yoga/event/event.cpp @@ -73,7 +73,10 @@ void Event::subscribe(std::function&& subscriber) { push(new Node{std::move(subscriber)}); } -void Event::publish(const YGNode& node, Type eventType, const Data& eventData) { +void Event::publish( + YGNodeConstRef node, + Type eventType, + const Data& eventData) { for (auto subscriber = subscribers.load(std::memory_order_relaxed); subscriber != nullptr; subscriber = subscriber->next) { diff --git a/packages/react-native/ReactCommon/yoga/yoga/event/event.h b/packages/react-native/ReactCommon/yoga/yoga/event/event.h index 4c34fa66d60..3798e4663e7 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/event/event.h +++ b/packages/react-native/ReactCommon/yoga/yoga/event/event.h @@ -7,15 +7,13 @@ #pragma once +#include + #include #include #include -#include #include -struct YGConfig; -struct YGNode; - namespace facebook::yoga { enum struct LayoutType : int { @@ -63,7 +61,7 @@ struct YOGA_EXPORT Event { NodeBaselineEnd, }; class Data; - using Subscriber = void(const YGNode&, Type, Data); + using Subscriber = void(YGNodeConstRef, Type, Data); using Subscribers = std::vector>; template @@ -87,27 +85,22 @@ struct YOGA_EXPORT Event { static void subscribe(std::function&& subscriber); template - static void publish(const YGNode& node, const TypedData& eventData = {}) { + static void publish(YGNodeConstRef node, const TypedData& eventData = {}) { publish(node, E, Data{eventData}); } - template - static void publish(const YGNode* node, const TypedData& eventData = {}) { - publish(*node, eventData); - } - private: - static void publish(const YGNode&, Type, const Data&); + static void publish(YGNodeConstRef, Type, const Data&); }; template <> struct Event::TypedData { - YGConfig* config; + YGConfigRef config; }; template <> struct Event::TypedData { - YGConfig* config; + YGConfigRef config; }; template <> diff --git a/packages/react-native/ReactCommon/yoga/yoga/log.cpp b/packages/react-native/ReactCommon/yoga/yoga/log.cpp index eb776629ddb..3dc62c517d9 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/log.cpp +++ b/packages/react-native/ReactCommon/yoga/yoga/log.cpp @@ -9,7 +9,7 @@ #include "log.h" #include -#include "YGNode.h" +#include namespace facebook::yoga::detail { @@ -17,7 +17,7 @@ namespace { void vlog( yoga::Config* config, - YGNode* node, + yoga::Node* node, YGLogLevel level, void* context, const char* format, @@ -30,7 +30,7 @@ void vlog( } // namespace YOGA_EXPORT void Log::log( - YGNode* node, + yoga::Node* node, YGLogLevel level, void* context, const char* format, diff --git a/packages/react-native/ReactCommon/yoga/yoga/log.h b/packages/react-native/ReactCommon/yoga/yoga/log.h index ad0fe4d6f52..3d468ae10c2 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/log.h +++ b/packages/react-native/ReactCommon/yoga/yoga/log.h @@ -8,16 +8,14 @@ #pragma once #include +#include #include -struct YGNode; -struct YGConfig; - namespace facebook::yoga::detail { struct Log { static void log( - YGNode* node, + yoga::Node* node, YGLogLevel level, void*, const char* message, diff --git a/packages/react-native/ReactCommon/yoga/yoga/YGLayout.cpp b/packages/react-native/ReactCommon/yoga/yoga/node/LayoutResults.cpp similarity index 88% rename from packages/react-native/ReactCommon/yoga/yoga/YGLayout.cpp rename to packages/react-native/ReactCommon/yoga/yoga/node/LayoutResults.cpp index 9aadcd4aecd..d6611aa159b 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/YGLayout.cpp +++ b/packages/react-native/ReactCommon/yoga/yoga/node/LayoutResults.cpp @@ -5,12 +5,12 @@ * LICENSE file in the root directory of this source tree. */ -#include "YGLayout.h" -#include "Utils.h" +#include +#include -using namespace facebook; +namespace facebook::yoga { -bool YGLayout::operator==(YGLayout layout) const { +bool LayoutResults::operator==(LayoutResults layout) const { bool isEqual = YGFloatArrayEqual(position, layout.position) && YGFloatArrayEqual(dimensions, layout.dimensions) && YGFloatArrayEqual(margin, layout.margin) && @@ -40,3 +40,5 @@ bool YGLayout::operator==(YGLayout layout) const { return isEqual; } + +} // namespace facebook::yoga diff --git a/packages/react-native/ReactCommon/yoga/yoga/YGLayout.h b/packages/react-native/ReactCommon/yoga/yoga/node/LayoutResults.h similarity index 89% rename from packages/react-native/ReactCommon/yoga/yoga/YGLayout.h rename to packages/react-native/ReactCommon/yoga/yoga/node/LayoutResults.h index 78a1bcf1918..18cc135f2c6 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/YGLayout.h +++ b/packages/react-native/ReactCommon/yoga/yoga/node/LayoutResults.h @@ -11,7 +11,9 @@ #include #include -struct YGLayout { +namespace facebook::yoga { + +struct LayoutResults { std::array position = {}; std::array dimensions = {{YGUndefined, YGUndefined}}; std::array margin = {}; @@ -58,6 +60,8 @@ public: flags, hadOverflowOffset, hadOverflow); } - bool operator==(YGLayout layout) const; - bool operator!=(YGLayout layout) const { return !(*this == layout); } + bool operator==(LayoutResults layout) const; + bool operator!=(LayoutResults layout) const { return !(*this == layout); } }; + +} // namespace facebook::yoga diff --git a/packages/react-native/ReactCommon/yoga/yoga/YGNode.cpp b/packages/react-native/ReactCommon/yoga/yoga/node/Node.cpp similarity index 79% rename from packages/react-native/ReactCommon/yoga/yoga/YGNode.cpp rename to packages/react-native/ReactCommon/yoga/yoga/node/Node.cpp index 7389354e68d..f0b355cf353 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/YGNode.cpp +++ b/packages/react-native/ReactCommon/yoga/yoga/node/Node.cpp @@ -5,18 +5,15 @@ * LICENSE file in the root directory of this source tree. */ -#include "YGNode.h" +#include #include #include -#include "Utils.h" +#include -using namespace facebook; -using namespace facebook::yoga; -using facebook::yoga::CompactValue; +namespace facebook::yoga { -YGNode::YGNode(yoga::Config* config) : config_{config} { - YGAssert( - config != nullptr, "Attempting to construct YGNode with null config"); +Node::Node(yoga::Config* config) : config_{config} { + YGAssert(config != nullptr, "Attempting to construct Node with null config"); flags_.hasNewLayout = true; if (config->useWebDefaults()) { @@ -24,7 +21,7 @@ YGNode::YGNode(yoga::Config* config) : config_{config} { } } -YGNode::YGNode(YGNode&& node) { +Node::Node(Node&& node) { context_ = node.context_; flags_ = node.flags_; measure_ = node.measure_; @@ -43,7 +40,7 @@ YGNode::YGNode(YGNode&& node) { } } -void YGNode::print(void* printContext) { +void Node::print(void* printContext) { if (print_.noContext != nullptr) { if (flags_.printUsesContext) { print_.withContext(this, printContext); @@ -53,7 +50,7 @@ void YGNode::print(void* printContext) { } } -CompactValue YGNode::computeEdgeValueForRow( +CompactValue Node::computeEdgeValueForRow( const Style::Edges& edges, YGEdge rowEdge, YGEdge edge, @@ -71,7 +68,7 @@ CompactValue YGNode::computeEdgeValueForRow( } } -CompactValue YGNode::computeEdgeValueForColumn( +CompactValue Node::computeEdgeValueForColumn( const Style::Edges& edges, YGEdge edge, CompactValue defaultValue) { @@ -86,7 +83,7 @@ CompactValue YGNode::computeEdgeValueForColumn( } } -CompactValue YGNode::computeRowGap( +CompactValue Node::computeRowGap( const Style::Gutters& gutters, CompactValue defaultValue) { if (!gutters[YGGutterRow].isUndefined()) { @@ -98,7 +95,7 @@ CompactValue YGNode::computeRowGap( } } -CompactValue YGNode::computeColumnGap( +CompactValue Node::computeColumnGap( const Style::Gutters& gutters, CompactValue defaultValue) { if (!gutters[YGGutterColumn].isUndefined()) { @@ -110,7 +107,7 @@ CompactValue YGNode::computeColumnGap( } } -YGFloatOptional YGNode::getLeadingPosition( +YGFloatOptional Node::getLeadingPosition( const YGFlexDirection axis, const float axisSize) const { auto leadingPosition = YGFlexDirectionIsRow(axis) @@ -124,7 +121,7 @@ YGFloatOptional YGNode::getLeadingPosition( return YGResolveValue(leadingPosition, axisSize); } -YGFloatOptional YGNode::getTrailingPosition( +YGFloatOptional Node::getTrailingPosition( const YGFlexDirection axis, const float axisSize) const { auto trailingPosition = YGFlexDirectionIsRow(axis) @@ -138,7 +135,7 @@ YGFloatOptional YGNode::getTrailingPosition( return YGResolveValue(trailingPosition, axisSize); } -bool YGNode::isLeadingPositionDefined(const YGFlexDirection axis) const { +bool Node::isLeadingPositionDefined(const YGFlexDirection axis) const { auto leadingPosition = YGFlexDirectionIsRow(axis) ? computeEdgeValueForRow( style_.position(), @@ -150,7 +147,7 @@ bool YGNode::isLeadingPositionDefined(const YGFlexDirection axis) const { return !leadingPosition.isUndefined(); } -bool YGNode::isTrailingPosDefined(const YGFlexDirection axis) const { +bool Node::isTrailingPosDefined(const YGFlexDirection axis) const { auto trailingPosition = YGFlexDirectionIsRow(axis) ? computeEdgeValueForRow( style_.position(), @@ -162,7 +159,7 @@ bool YGNode::isTrailingPosDefined(const YGFlexDirection axis) const { return !trailingPosition.isUndefined(); } -YGFloatOptional YGNode::getLeadingMargin( +YGFloatOptional Node::getLeadingMargin( const YGFlexDirection axis, const float widthSize) const { auto leadingMargin = YGFlexDirectionIsRow(axis) @@ -173,7 +170,7 @@ YGFloatOptional YGNode::getLeadingMargin( return YGResolveValueMargin(leadingMargin, widthSize); } -YGFloatOptional YGNode::getTrailingMargin( +YGFloatOptional Node::getTrailingMargin( const YGFlexDirection axis, const float widthSize) const { auto trailingMargin = YGFlexDirectionIsRow(axis) @@ -184,13 +181,13 @@ YGFloatOptional YGNode::getTrailingMargin( return YGResolveValueMargin(trailingMargin, widthSize); } -YGFloatOptional YGNode::getMarginForAxis( +YGFloatOptional Node::getMarginForAxis( const YGFlexDirection axis, const float widthSize) const { return getLeadingMargin(axis, widthSize) + getTrailingMargin(axis, widthSize); } -YGFloatOptional YGNode::getGapForAxis( +YGFloatOptional Node::getGapForAxis( const YGFlexDirection axis, const float widthSize) const { auto gap = YGFlexDirectionIsRow(axis) @@ -199,7 +196,7 @@ YGFloatOptional YGNode::getGapForAxis( return YGResolveValue(gap, widthSize); } -YGSize YGNode::measure( +YGSize Node::measure( float width, YGMeasureMode widthMode, float height, @@ -211,7 +208,7 @@ YGSize YGNode::measure( : measure_.noContext(this, width, widthMode, height, heightMode); } -float YGNode::baseline(float width, float height, void* layoutContext) { +float Node::baseline(float width, float height, void* layoutContext) { return flags_.baselineUsesContext ? baseline_.withContext(this, width, height, layoutContext) : baseline_.noContext(this, width, height); @@ -219,7 +216,7 @@ float YGNode::baseline(float width, float height, void* layoutContext) { // Setters -void YGNode::setMeasureFunc(decltype(YGNode::measure_) measureFunc) { +void Node::setMeasureFunc(decltype(Node::measure_) measureFunc) { if (measureFunc.noContext == nullptr) { // TODO: t18095186 Move nodeType to opt-in function and mark appropriate // places in Litho @@ -238,38 +235,38 @@ void YGNode::setMeasureFunc(decltype(YGNode::measure_) measureFunc) { measure_ = measureFunc; } -void YGNode::setMeasureFunc(YGMeasureFunc measureFunc) { +void Node::setMeasureFunc(YGMeasureFunc measureFunc) { flags_.measureUsesContext = false; - decltype(YGNode::measure_) m; + decltype(Node::measure_) m; m.noContext = measureFunc; setMeasureFunc(m); } -YOGA_EXPORT void YGNode::setMeasureFunc(MeasureWithContextFn measureFunc) { +YOGA_EXPORT void Node::setMeasureFunc(MeasureWithContextFn measureFunc) { flags_.measureUsesContext = true; - decltype(YGNode::measure_) m; + decltype(Node::measure_) m; m.withContext = measureFunc; setMeasureFunc(m); } -void YGNode::replaceChild(YGNodeRef child, uint32_t index) { +void Node::replaceChild(Node* child, uint32_t index) { children_[index] = child; } -void YGNode::replaceChild(YGNodeRef oldChild, YGNodeRef newChild) { +void Node::replaceChild(Node* oldChild, Node* newChild) { std::replace(children_.begin(), children_.end(), oldChild, newChild); } -void YGNode::insertChild(YGNodeRef child, uint32_t index) { +void Node::insertChild(Node* child, uint32_t index) { children_.insert(children_.begin() + index, child); } -void YGNode::setConfig(yoga::Config* config) { - YGAssert(config != nullptr, "Attempting to set a null config on a YGNode"); +void Node::setConfig(yoga::Config* config) { + YGAssert(config != nullptr, "Attempting to set a null config on a Node"); YGAssertWithConfig( config, config->useWebDefaults() == config_->useWebDefaults(), - "UseWebDefaults may not be changed after constructing a YGNode"); + "UseWebDefaults may not be changed after constructing a Node"); if (yoga::configUpdateInvalidatesLayout(config_, config)) { markDirtyAndPropagate(); @@ -278,7 +275,7 @@ void YGNode::setConfig(yoga::Config* config) { config_ = config; } -void YGNode::setDirty(bool isDirty) { +void Node::setDirty(bool isDirty) { if (isDirty == flags_.isDirty) { return; } @@ -288,8 +285,8 @@ void YGNode::setDirty(bool isDirty) { } } -bool YGNode::removeChild(YGNodeRef child) { - std::vector::iterator p = +bool Node::removeChild(Node* child) { + std::vector::iterator p = std::find(children_.begin(), children_.end(), child); if (p != children_.end()) { children_.erase(p); @@ -298,59 +295,58 @@ bool YGNode::removeChild(YGNodeRef child) { return false; } -void YGNode::removeChild(uint32_t index) { +void Node::removeChild(uint32_t index) { children_.erase(children_.begin() + index); } -void YGNode::setLayoutDirection(YGDirection direction) { +void Node::setLayoutDirection(YGDirection direction) { layout_.setDirection(direction); } -void YGNode::setLayoutMargin(float margin, int index) { +void Node::setLayoutMargin(float margin, int index) { layout_.margin[index] = margin; } -void YGNode::setLayoutBorder(float border, int index) { +void Node::setLayoutBorder(float border, int index) { layout_.border[index] = border; } -void YGNode::setLayoutPadding(float padding, int index) { +void Node::setLayoutPadding(float padding, int index) { layout_.padding[index] = padding; } -void YGNode::setLayoutLastOwnerDirection(YGDirection direction) { +void Node::setLayoutLastOwnerDirection(YGDirection direction) { layout_.lastOwnerDirection = direction; } -void YGNode::setLayoutComputedFlexBasis( - const YGFloatOptional computedFlexBasis) { +void Node::setLayoutComputedFlexBasis(const YGFloatOptional computedFlexBasis) { layout_.computedFlexBasis = computedFlexBasis; } -void YGNode::setLayoutPosition(float position, int index) { +void Node::setLayoutPosition(float position, int index) { layout_.position[index] = position; } -void YGNode::setLayoutComputedFlexBasisGeneration( +void Node::setLayoutComputedFlexBasisGeneration( uint32_t computedFlexBasisGeneration) { layout_.computedFlexBasisGeneration = computedFlexBasisGeneration; } -void YGNode::setLayoutMeasuredDimension(float measuredDimension, int index) { +void Node::setLayoutMeasuredDimension(float measuredDimension, int index) { layout_.measuredDimensions[index] = measuredDimension; } -void YGNode::setLayoutHadOverflow(bool hadOverflow) { +void Node::setLayoutHadOverflow(bool hadOverflow) { layout_.setHadOverflow(hadOverflow); } -void YGNode::setLayoutDimension(float dimension, int index) { +void Node::setLayoutDimension(float dimension, int index) { layout_.dimensions[index] = dimension; } // If both left and right are defined, then use left. Otherwise return +left or // -right depending on which is defined. -YGFloatOptional YGNode::relativePosition( +YGFloatOptional Node::relativePosition( const YGFlexDirection axis, const float axisSize) const { if (isLeadingPositionDefined(axis)) { @@ -364,7 +360,7 @@ YGFloatOptional YGNode::relativePosition( return trailingPosition; } -void YGNode::setPosition( +void Node::setPosition( const YGDirection direction, const float mainSize, const float crossSize, @@ -402,7 +398,7 @@ void YGNode::setPosition( trailing[crossAxis]); } -YGValue YGNode::marginLeadingValue(const YGFlexDirection axis) const { +YGValue Node::marginLeadingValue(const YGFlexDirection axis) const { if (YGFlexDirectionIsRow(axis) && !style_.margin()[YGEdgeStart].isUndefined()) { return style_.margin()[YGEdgeStart]; @@ -411,7 +407,7 @@ YGValue YGNode::marginLeadingValue(const YGFlexDirection axis) const { } } -YGValue YGNode::marginTrailingValue(const YGFlexDirection axis) const { +YGValue Node::marginTrailingValue(const YGFlexDirection axis) const { if (YGFlexDirectionIsRow(axis) && !style_.margin()[YGEdgeEnd].isUndefined()) { return style_.margin()[YGEdgeEnd]; } else { @@ -419,7 +415,7 @@ YGValue YGNode::marginTrailingValue(const YGFlexDirection axis) const { } } -YGValue YGNode::resolveFlexBasisPtr() const { +YGValue Node::resolveFlexBasisPtr() const { YGValue flexBasis = style_.flexBasis(); if (flexBasis.unit != YGUnitAuto && flexBasis.unit != YGUnitUndefined) { return flexBasis; @@ -430,7 +426,7 @@ YGValue YGNode::resolveFlexBasisPtr() const { return YGValueAuto; } -void YGNode::resolveDimension() { +void Node::resolveDimension() { using namespace yoga; const Style& style = getStyle(); for (auto dim : {YGDimensionWidth, YGDimensionHeight}) { @@ -443,7 +439,7 @@ void YGNode::resolveDimension() { } } -YGDirection YGNode::resolveDirection(const YGDirection ownerDirection) { +YGDirection Node::resolveDirection(const YGDirection ownerDirection) { if (style_.direction() == YGDirectionInherit) { return ownerDirection > YGDirectionInherit ? ownerDirection : YGDirectionLTR; @@ -452,18 +448,18 @@ YGDirection YGNode::resolveDirection(const YGDirection ownerDirection) { } } -YOGA_EXPORT void YGNode::clearChildren() { +YOGA_EXPORT void Node::clearChildren() { children_.clear(); children_.shrink_to_fit(); } // Other Methods -void YGNode::cloneChildrenIfNeeded(void* cloneContext) { - iterChildrenAfterCloningIfNeeded([](YGNodeRef, void*) {}, cloneContext); +void Node::cloneChildrenIfNeeded(void* cloneContext) { + iterChildrenAfterCloningIfNeeded([](Node*, void*) {}, cloneContext); } -void YGNode::markDirtyAndPropagate() { +void Node::markDirtyAndPropagate() { if (!flags_.isDirty) { setDirty(true); setLayoutComputedFlexBasis(YGFloatOptional()); @@ -473,14 +469,14 @@ void YGNode::markDirtyAndPropagate() { } } -void YGNode::markDirtyAndPropagateDownwards() { +void Node::markDirtyAndPropagateDownwards() { flags_.isDirty = true; - for_each(children_.begin(), children_.end(), [](YGNodeRef childNode) { + for_each(children_.begin(), children_.end(), [](Node* childNode) { childNode->markDirtyAndPropagateDownwards(); }); } -float YGNode::resolveFlexGrow() const { +float Node::resolveFlexGrow() const { // Root nodes flexGrow should always be 0 if (owner_ == nullptr) { return 0.0; @@ -494,7 +490,7 @@ float YGNode::resolveFlexGrow() const { return kDefaultFlexGrow; } -float YGNode::resolveFlexShrink() const { +float Node::resolveFlexShrink() const { if (owner_ == nullptr) { return 0.0; } @@ -508,13 +504,13 @@ float YGNode::resolveFlexShrink() const { return config_->useWebDefaults() ? kWebDefaultFlexShrink : kDefaultFlexShrink; } -bool YGNode::isNodeFlexible() { +bool Node::isNodeFlexible() { return ( (style_.positionType() != YGPositionTypeAbsolute) && (resolveFlexGrow() != 0 || resolveFlexShrink() != 0)); } -float YGNode::getLeadingBorder(const YGFlexDirection axis) const { +float Node::getLeadingBorder(const YGFlexDirection axis) const { YGValue leadingBorder = YGFlexDirectionIsRow(axis) ? computeEdgeValueForRow( style_.border(), YGEdgeStart, leading[axis], CompactValue::ofZero()) @@ -523,7 +519,7 @@ float YGNode::getLeadingBorder(const YGFlexDirection axis) const { return fmaxf(leadingBorder.value, 0.0f); } -float YGNode::getTrailingBorder(const YGFlexDirection axis) const { +float Node::getTrailingBorder(const YGFlexDirection axis) const { YGValue trailingBorder = YGFlexDirectionIsRow(axis) ? computeEdgeValueForRow( style_.border(), YGEdgeEnd, trailing[axis], CompactValue::ofZero()) @@ -532,7 +528,7 @@ float YGNode::getTrailingBorder(const YGFlexDirection axis) const { return fmaxf(trailingBorder.value, 0.0f); } -YGFloatOptional YGNode::getLeadingPadding( +YGFloatOptional Node::getLeadingPadding( const YGFlexDirection axis, const float widthSize) const { auto leadingPadding = YGFlexDirectionIsRow(axis) @@ -547,7 +543,7 @@ YGFloatOptional YGNode::getLeadingPadding( YGResolveValue(leadingPadding, widthSize), YGFloatOptional(0.0f)); } -YGFloatOptional YGNode::getTrailingPadding( +YGFloatOptional Node::getTrailingPadding( const YGFlexDirection axis, const float widthSize) const { auto trailingPadding = YGFlexDirectionIsRow(axis) @@ -559,21 +555,21 @@ YGFloatOptional YGNode::getTrailingPadding( YGResolveValue(trailingPadding, widthSize), YGFloatOptional(0.0f)); } -YGFloatOptional YGNode::getLeadingPaddingAndBorder( +YGFloatOptional Node::getLeadingPaddingAndBorder( const YGFlexDirection axis, const float widthSize) const { return getLeadingPadding(axis, widthSize) + YGFloatOptional(getLeadingBorder(axis)); } -YGFloatOptional YGNode::getTrailingPaddingAndBorder( +YGFloatOptional Node::getTrailingPaddingAndBorder( const YGFlexDirection axis, const float widthSize) const { return getTrailingPadding(axis, widthSize) + YGFloatOptional(getTrailingBorder(axis)); } -void YGNode::reset() { +void Node::reset() { YGAssertWithNode( this, children_.size() == 0, @@ -581,5 +577,7 @@ void YGNode::reset() { YGAssertWithNode( this, owner_ == nullptr, "Cannot reset a node still attached to a owner"); - *this = YGNode{getConfig()}; + *this = Node{getConfig()}; } + +} // namespace facebook::yoga diff --git a/packages/react-native/ReactCommon/yoga/yoga/YGNode.h b/packages/react-native/ReactCommon/yoga/yoga/node/Node.h similarity index 78% rename from packages/react-native/ReactCommon/yoga/yoga/YGNode.h rename to packages/react-native/ReactCommon/yoga/yoga/node/Node.h index 218cb989ffe..abb1535aed5 100644 --- a/packages/react-native/ReactCommon/yoga/yoga/YGNode.h +++ b/packages/react-native/ReactCommon/yoga/yoga/node/Node.h @@ -10,15 +10,20 @@ #include #include #include -#include "YGLayout.h" +#include #include #include #include +// Tag struct used to form the opaque YGNodeRef for the public C API +struct YGNode {}; + +namespace facebook::yoga { + #pragma pack(push) #pragma pack(1) -struct YGNodeFlags { +struct NodeFlags { bool hasNewLayout : 1; bool isReferenceBaseline : 1; bool isDirty : 1; @@ -29,7 +34,8 @@ struct YGNodeFlags { }; #pragma pack(pop) -struct YOGA_EXPORT YGNode { +class YOGA_EXPORT Node : public ::YGNode { +public: using MeasureWithContextFn = YGSize (*)(YGNode*, float, YGMeasureMode, float, YGMeasureMode, void*); using BaselineWithContextFn = float (*)(YGNode*, float, float, void*); @@ -37,7 +43,7 @@ struct YOGA_EXPORT YGNode { private: void* context_ = nullptr; - YGNodeFlags flags_ = {}; + NodeFlags flags_ = {}; union { YGMeasureFunc noContext; MeasureWithContextFn withContext; @@ -51,12 +57,12 @@ private: PrintWithContextFn withContext; } print_ = {nullptr}; YGDirtiedFunc dirtied_ = nullptr; - facebook::yoga::Style style_ = {}; - YGLayout layout_ = {}; + Style style_ = {}; + LayoutResults layout_ = {}; uint32_t lineIndex_ = 0; - YGNodeRef owner_ = nullptr; - YGVector children_ = {}; - facebook::yoga::Config* config_; + Node* owner_ = nullptr; + std::vector children_ = {}; + Config* config_; std::array resolvedDimensions_ = { {YGValueUndefined, YGValueUndefined}}; @@ -77,27 +83,24 @@ private: // them (potentially incorrect) or ignore them (danger of leaks). Only ever // use this after checking that there are no children. // DO NOT CHANGE THE VISIBILITY OF THIS METHOD! - YGNode& operator=(YGNode&&) = default; - - using CompactValue = facebook::yoga::CompactValue; + Node& operator=(Node&&) = default; public: - YGNode() - : YGNode{static_cast(YGConfigGetDefault())} { + Node() : Node{static_cast(YGConfigGetDefault())} { flags_.hasNewLayout = true; } - explicit YGNode(facebook::yoga::Config* config); - ~YGNode() = default; // cleanup of owner/children relationships in YGNodeFree + explicit Node(Config* config); + ~Node() = default; // cleanup of owner/children relationships in YGNodeFree - YGNode(YGNode&&); + Node(Node&&); // Does not expose true value semantics, as children are not cloned eagerly. // Should we remove this? - YGNode(const YGNode& node) = default; + Node(const Node& node) = default; // assignment means potential leaks of existing children, or alternatively // freeing unowned memory, double free, or freeing stack memory. - YGNode& operator=(const YGNode&) = delete; + Node& operator=(const Node&) = delete; // Getters void* getContext() const { return context_; } @@ -125,38 +128,39 @@ public: YGDirtiedFunc getDirtied() const { return dirtied_; } // For Performance reasons passing as reference. - facebook::yoga::Style& getStyle() { return style_; } + Style& getStyle() { return style_; } - const facebook::yoga::Style& getStyle() const { return style_; } + const Style& getStyle() const { return style_; } // For Performance reasons passing as reference. - YGLayout& getLayout() { return layout_; } + LayoutResults& getLayout() { return layout_; } - const YGLayout& getLayout() const { return layout_; } + const LayoutResults& getLayout() const { return layout_; } uint32_t getLineIndex() const { return lineIndex_; } bool isReferenceBaseline() { return flags_.isReferenceBaseline; } - // returns the YGNodeRef that owns this YGNode. An owner is used to identify - // the YogaTree that a YGNode belongs to. This method will return the parent - // of the YGNode when a YGNode only belongs to one YogaTree or nullptr when - // the YGNode is shared between two or more YogaTrees. - YGNodeRef getOwner() const { return owner_; } + // returns the Node that owns this Node. An owner is used to identify + // the YogaTree that a Node belongs to. This method will return the parent + // of the Node when a Node only belongs to one YogaTree or nullptr when + // the Node is shared between two or more YogaTrees. + Node* getOwner() const { return owner_; } // Deprecated, use getOwner() instead. - YGNodeRef getParent() const { return getOwner(); } + Node* getParent() const { return getOwner(); } - const YGVector& getChildren() const { return children_; } + const std::vector& getChildren() const { return children_; } // Applies a callback to all children, after cloning them if they are not // owned. template void iterChildrenAfterCloningIfNeeded(T callback, void* cloneContext) { int i = 0; - for (YGNodeRef& child : children_) { + for (Node*& child : children_) { if (child->getOwner() != this) { - child = config_->cloneNode(child, this, i, cloneContext); + child = static_cast( + config_->cloneNode(child, this, i, cloneContext)); child->setOwner(this); } i += 1; @@ -165,9 +169,9 @@ public: } } - YGNodeRef getChild(uint32_t index) const { return children_.at(index); } + Node* getChild(uint32_t index) const { return children_.at(index); } - facebook::yoga::Config* getConfig() const { return config_; } + Config* getConfig() const { return config_; } bool isDirty() const { return flags_.isDirty; } @@ -180,22 +184,22 @@ public: } static CompactValue computeEdgeValueForColumn( - const facebook::yoga::Style::Edges& edges, + const Style::Edges& edges, YGEdge edge, CompactValue defaultValue); static CompactValue computeEdgeValueForRow( - const facebook::yoga::Style::Edges& edges, + const Style::Edges& edges, YGEdge rowEdge, YGEdge edge, CompactValue defaultValue); static CompactValue computeRowGap( - const facebook::yoga::Style::Gutters& gutters, + const Style::Gutters& gutters, CompactValue defaultValue); static CompactValue computeColumnGap( - const facebook::yoga::Style::Gutters& gutters, + const Style::Gutters& gutters, CompactValue defaultValue); // Methods related to positions, margin, padding and border @@ -275,9 +279,9 @@ public: void setDirtiedFunc(YGDirtiedFunc dirtiedFunc) { dirtied_ = dirtiedFunc; } - void setStyle(const facebook::yoga::Style& style) { style_ = style; } + void setStyle(const Style& style) { style_ = style; } - void setLayout(const YGLayout& layout) { layout_ = layout; } + void setLayout(const LayoutResults& layout) { layout_ = layout; } void setLineIndex(uint32_t lineIndex) { lineIndex_ = lineIndex; } @@ -285,13 +289,13 @@ public: flags_.isReferenceBaseline = isReferenceBaseline; } - void setOwner(YGNodeRef owner) { owner_ = owner; } + void setOwner(Node* owner) { owner_ = owner; } - void setChildren(const YGVector& children) { children_ = children; } + void setChildren(const std::vector& children) { children_ = children; } // TODO: rvalue override for setChildren - void setConfig(facebook::yoga::Config* config); + void setConfig(Config* config); void setDirty(bool isDirty); void setLayoutLastOwnerDirection(YGDirection direction); @@ -321,11 +325,11 @@ public: YGDirection resolveDirection(const YGDirection ownerDirection); void clearChildren(); /// Replaces the occurrences of oldChild with newChild - void replaceChild(YGNodeRef oldChild, YGNodeRef newChild); - void replaceChild(YGNodeRef child, uint32_t index); - void insertChild(YGNodeRef child, uint32_t index); + void replaceChild(Node* oldChild, Node* newChild); + void replaceChild(Node* child, uint32_t index); + void insertChild(Node* child, uint32_t index); /// Removes the first occurrence of child - bool removeChild(YGNodeRef child); + bool removeChild(Node* child); void removeChild(uint32_t index); void cloneChildrenIfNeeded(void*); @@ -335,3 +339,5 @@ public: bool isNodeFlexible(); void reset(); }; + +} // namespace facebook::yoga