struct YGCachedMeasurement {
   float availableWidth;                 //最大有效宽度。一般为父容器宽度
   float availableHeight;                //高度：同上
   YGMeasureMode widthMeasureMode;       //本次缓存的计算模式
   YGMeasureMode heightMeasureMode;      //同上

   float computedWidth;                  //经过计算之后的计算宽度
   float computedHeight;                 //同上
}

static void YGRoundToPixelGrid(
    const YGNodeRef node,
    const float pointScaleFactor,
    const float absoluteLeft,
    const float absoluteTop) {
  if (pointScaleFactor == 0.0f) {
    return;
  }

  const float nodeLeft = node->getLayout().position[YGEdgeLeft];
  const float nodeTop = node->getLayout().position[YGEdgeTop];

  const float nodeWidth = node->getLayout().dimensions[YGDimensionWidth];
  const float nodeHeight = node->getLayout().dimensions[YGDimensionHeight];

  const float absoluteNodeLeft = absoluteLeft + nodeLeft;
  const float absoluteNodeTop = absoluteTop + nodeTop;

  const float absoluteNodeRight = absoluteNodeLeft + nodeWidth;
  const float absoluteNodeBottom = absoluteNodeTop + nodeHeight;

  // If a node has a custom measure function we never want to round down its
  // size as this could lead to unwanted text truncation.
  const bool textRounding = node->getNodeType() == YGNodeTypeText;

  node->setLayoutPosition(
      YGRoundValueToPixelGrid(nodeLeft, pointScaleFactor, false, textRounding),
      YGEdgeLeft);

  node->setLayoutPosition(
      YGRoundValueToPixelGrid(nodeTop, pointScaleFactor, false, textRounding),
      YGEdgeTop);

  // We multiply dimension by scale factor and if the result is close to the
  // whole number, we don't have any fraction To verify if the result is close
  // to whole number we want to check both floor and ceil numbers
    float mod = fmodf(nodeWidth * pointScaleFactor, 1.0);

    //是否高度或者宽度不是整数，如：3.8，3.1 这样
  const bool hasFractionalWidth =
      !YGFloatsEqual(mod, 0) &&
      !YGFloatsEqual(mod, 1.0);
  const bool hasFractionalHeight =
      !YGFloatsEqual(fmodf(nodeHeight * pointScaleFactor, 1.0), 0) &&
      !YGFloatsEqual(fmodf(nodeHeight * pointScaleFactor, 1.0), 1.0);
//当宽度不是整数（有余数）时。对于文本的内容应该向上取整。
//但由于YGFloatsEqual内部，在float比较时，精度为0.0001f。导致某些极端的情况下，文本内容被截断
//如：文本宽度刚好为 3.0000999，此时会被认定为3，导致文本显示不全。
  node->setLayoutDimension(
      YGRoundValueToPixelGrid(
          absoluteNodeRight,
          pointScaleFactor,
          (textRounding && hasFractionalWidth),
          (textRounding && !hasFractionalWidth)) -
          YGRoundValueToPixelGrid(
              absoluteNodeLeft, pointScaleFactor, false, textRounding),
      YGDimensionWidth);

  node->setLayoutDimension(
      YGRoundValueToPixelGrid(
          absoluteNodeBottom,
          pointScaleFactor,
          (textRounding && hasFractionalHeight),
          (textRounding && !hasFractionalHeight)) -
          YGRoundValueToPixelGrid(
              absoluteNodeTop, pointScaleFactor, false, textRounding),
      YGDimensionHeight);

  const uint32_t childCount = YGNodeGetChildCount(node);
  for (uint32_t i = 0; i < childCount; i++) {
    YGRoundToPixelGrid(
        YGNodeGetChild(node, i),
        pointScaleFactor,
        absoluteNodeLeft,
        absoluteNodeTop);
  }
}

/ Adding epsilon value illuminates problems with converting values from
// `double` to `float`, and then rounding them to pixel grid in Yoga.
CGFloat epsilon = 0.001;
return (YGSize){
  RCTYogaFloatFromCoreGraphicsFloat(size.width + epsilon),
  RCTYogaFloatFromCoreGraphicsFloat(size.height + epsilon)
};

[self.view configureLayoutWithBlock:^(YGLayout * layout) {
    layout.isEnabled = YES;
    layout.flexDirection = YGFlexDirectionRow;
    layout.justifyContent = YGJustifySpaceBetween;
    layout.alignItems = YGAlignCenter;
    layout.height = YGPointValue(200);
}];

[self.view.yoga applyLayoutPreservingOrigin:NO];

#define YGChainedProperty(type, name) @property(readonly, getter=qm_##name) YGLayout *(^qm_##name)(type value);

@interface YGLayout (Category)
YGChainedProperty(YGDirection, direction)
YGChainedProperty(YGFlexDirection, flexDirection)
YGChainedProperty(YGJustify, justifyContent)
YGChainedProperty(YGAlign, alignContent)
···
@end

@interface UIView (YogaExtension)
/// 设置 isEnable 为 YES。跳过 configure
- (void)doYoga;
/// 设置 isEnable 为 YES。并配置 layout 属性
- (void)doYoga:(YGLayoutConfigurationBlock)block;
@end

[self.view doYoga:^(YGLayout * layout) {
    layout.qm_flexDirection(YGFlexDirectionRow)
    .qm_justifyContent(YGJustifySpaceBetween)
    .qm_alignItems(YGAlignCenter)
    .qm_height(200);
}];

- (void)applyLayoutPreservingOrigin:(BOOL)preserveOrigin
{
  [self calculateLayoutWithSize:self.view.bounds.size];
  YGApplyLayoutToViewHierarchy(self.view, preserveOrigin);
}

- (CGSize)calculateLayoutWithSize:(CGSize)size
{
  YGAttachNodesFromViewHierachy(self.view);
  const YGNodeRef node = self.node;

  YGNodeCalculateLayout(
    node,
    size.width,
    size.height,
    YGNodeStyleGetDirection(node));

  return (CGSize) {
    .width = YGNodeLayoutGetWidth(node),
    .height = YGNodeLayoutGetHeight(node),
  };
}

// Only leaf nodes should have a measure function
if (yoga.isLeaf) {
  YGRemoveAllChildren(node);
  YGNodeSetMeasureFunc(node, YGMeasureView);
} else {
  YGNodeSetMeasureFunc(node, NULL);
  ...
}

void YGNodeCalculateLayoutWithContext(
    const YGNodeRef node,
    const float ownerWidth,
    const float ownerHeight,
    const YGDirection ownerDirection,
    void* layoutContext) {
  marker::MarkerSection marker{node};

  // 每一次进入排版，都会自增该值，主要是用于确保被设置为 dirty 的项目在父视图给定空间不变时，
  // 都只会被递归遍历一次。另外有些情况会略过子项目的大小测量与排版，例如当父视图的最大宽度为 0 
  gCurrentGenerationCount++;

  // 初始化下节点的尺寸（如果有设节点宽高｜最大宽高），放到一个 dimension 数组
  node->resolveDimension();
  // 确定宽高、以及测量模式
  float width = YGUndefined;
  YGMeasureMode widthMeasureMode = YGMeasureModeUndefined;

  // 省略过程即为确定过程，大致思路是宽度上先检查是不是有设定的宽度，
  // 如果有，width = style.width ｜ width = parentWidth * percent，mode = Exactly
  // 如果没有，检查是否有最大值设定
  // 如果有，width =  maxWidth | width = parentWidth * percent, mode = AtMost
  // 如果都没有，width = parentWidth, mode = parentWidth ? Exactly : Undefined
  ...

  float height = YGUndefined;
  YGMeasureMode heightMeasureMode = YGMeasureModeUndefined;

  // 高度测量同上
  ...

  // 这个函数则是实际上的计算布局核心入口，主要用于判断节点是否需要重新进行排版或测量，这个我们下面单独拎出来看
  if (YGLayoutNodeInternal(...)) {
    // 设置 node 的位置
    node->setPosition(node->getLayout().direction, ownerWidth, ownerHeight, ownerWidth);

    // 对所有排版信息进行四舍五入取整。这个取整还是有点意思，根据缩放比率进行四舍五入，
    // 得到缩放比率同级别的京都，可以保证在不同大小分辨率下不会出现一个像素的偏移
    YGRoundToPixelGrid(node, node->getConfig()->pointScaleFactor, 0.0f, 0.0f);
  }

      // 清理空间
    YGConfigFreeRecursive(originalNode);
    YGNodeFreeRecursive(originalNode);
  }
}

bool YGLayoutNodeInternal(
    const YGNodeRef node,
    const float availableWidth,
    const float availableHeight,
    const YGDirection ownerDirection,
    const YGMeasureMode widthMeasureMode,
    const YGMeasureMode heightMeasureMode,
    const float ownerWidth,
    const float ownerHeight,
    const bool performLayout,
    const char* reason,
    const YGConfigRef config,
    YGMarkerLayoutData& layoutMarkerData,
    void* const layoutContext) {
  // 获取当前节点的排版信息  
  YGLayout* layout = &node->getLayout();

  // 这个值只是用来调试日志的，可忽略，后面也忽略了日志记录的
  gDepth++;

  // 判断是否需要重新计算（节点是脏的 & 当前排版周期还未排版过）|（父亲排版节点方向变了）
  const bool needToVisitNode =
      (node->isDirty() && layout->generationCount != gCurrentGenerationCount) ||
      layout->lastOwnerDirection != ownerDirection;


  if (needToVisitNode) {
    // 如果需要重新计算，清理所有排版缓存
  }

  YGCachedMeasurement* cachedResults = nullptr;

  // 先检查有没有自身的测量函数，最开始的时候我们说过，生成渲染树的时候会设置叶子节点测量方法
  // 因为每个节点可能需要多次测量才能解决 flex 所有维度上的尺寸，所以放在最开头避免耗性能重复测量
  if (node->hasMeasureFunc()) {
    // 获取主轴 & 对称轴 margin
    const float marginAxisRow = node->getMarginForAxis(YGFlexDirectionRow, ownerWidth).unwrap();
    const float marginAxisColumn = node->getMarginForAxis(YGFlexDirectionColumn, ownerWidth).unwrap();

    // 先判断能不能使用当前缓存的排版
    if (YGNodeCanUseCachedMeasurement(...)) {
      cachedResults = &layout->cachedLayout;
    } else {
      // 标注1: 不行就遍历以往的缓存结果，看能不能找到一个能用的 
      for (uint32_t i = 0; i < layout->nextCachedMeasurementsIndex; i++) {
        if (YGNodeCanUseCachedMeasurement(...) {
          cachedResults = &layout->cachedMeasurements[i];
          break;
        }
      }
    }
  }
  // 没有自测量方法，如果需要排版，先判断是否已经排版过以及是否能用缓存，可用标准上面也有说到
  else if (performLayout) {
    if (width & height & widthMode & heightMode 均没变) {
      cachedResults = &layout->cachedLayout;
    }
  }
  // 从以往的测量缓存中检查下能不能用的，跟  相同
  else {
    ...
  }

  // 不需要重新测量，则存一下缓存
  if (!needToVisitNode && cachedResults != nullptr) {
    ...
  } 
  // 啥都没有，那就跳到真正对某个节点的测量排版方法并设置缓存等
  else {
    // 节点测量排版方法，不长不长，下面我们再拎出来单独看看
    YGNodelayoutImpl(...);
    // 先记录下排版方向    
    layout->lastOwnerDirection = ownerDirection;
    // 更新缓存
    ...
  }

  // 如果是排版，则设置下节点的尺寸以及更新 dirty
  if (performLayout) {
    ...
  }

  layout->generationCount = gCurrentGenerationCount;
  // true 为已经排版，false 则是跳过使用了缓存
  return (needToVisitNode || cachedResults == nullptr);
}

static void YGNodelayoutImpl(
    const YGNodeRef node,
    const float availableWidth, // 调整节点的可用大小
    const float availableHeight,
    const YGDirection ownerDirection, // node 的内联方向（从左往右，从右往左）
    const YGMeasureMode widthMeasureMode, // 测量模式
    const YGMeasureMode heightMeasureMode,
    const float ownerWidth,                    
    const float ownerHeight,
    const bool performLayout, // 是否需要布局节点以及节点子树
    const YGConfigRef config,
    YGMarkerLayoutData& layoutMarkerData,
    void* const layoutContext) {
  (performLayout ? layoutMarkerData.layouts : layoutMarkerData.measures) += 1;

  // 初始化布局方向 direction，然后根据布局方向调整 flexRowDirection ｜ flexColumnDirection
  const YGDirection direction = node->resolveDirection(ownerDirection);
  node->setLayoutDirection(direction);

  const YGFlexDirection flexRowDirection = YGResolveFlexDirection(YGFlexDirectionRow, direction);
  const YGFlexDirection flexColumnDirection = YGResolveFlexDirection(YGFlexDirectionColumn, direction);

  // 根据 flexRowDirection ｜ flexColumnDirection 设置 node 实际上下左右的 margin & border & padding，
  // 在盒子模型里，使用 edge 可以排除方向性的干扰。比如在 row 里的 padding-left，
  // 在 row-reseve 则实际相当于 padding-right。所以用 edge-start 可以去泛指一个起点边距。
  ...

  if (node->hasMeasureFunc()) {
    // 如果节点有自测量函数，则直接调用测量方法并返回。因为在 YGLayout+UIView.h 里代码有限制，
    // 有自测量方法的节点是不会有子节点的，所以这里可以直接返回
    ...
    return;
  }


  const uint32_t childCount = YGNodeGetChildCount(node);
  if (childCount == 0) {
      // 对于没有子节点的，使用可用的值（如果提供了它们）或最小尺寸（比如没有设置自身大小，那内部空间基本尺寸为 0，
    // 最终大小即 padding + border），在这一步就能获得节点自身大小
    return;
  }

  // 如果是不需要对子节点进行排版的，且确切知道节点尺寸的跳过(按照已知的在内部设置了节点测量尺寸)
  if (!performLayout && YGNodeFixedSizeSetMeasuredDimensions(...)) {
    return;
  }

  // 确保每个节点都是可变的副本
  node->cloneChildrenIfNeeded(layoutContext);
  // 重设布局标志，因为可能已经改变了
  node->setLayoutHadOverflow(false);

  // STEP 1: 计算主轴交叉轴的剩余空间
  // 根据 direction 调整主轴的实际方向（因为 direction 如果为从右到左 RTL，那 row 对于 LTR 方向就是 row-reserve，
  // 所以都统一调整为 LTR 的方向再进行计算），并获取主轴 & 交叉轴的尺寸
  const YGFlexDirection mainAxis = YGResolveFlexDirection(node->getStyle().flexDirection, direction);
  const YGFlexDirection crossAxis = YGFlexDirectionCross(mainAxis, direction);

  const bool isMainAxisRow = YGFlexDirectionIsRow(mainAxis);
  const bool isNodeFlexWrap = node->getStyle().flexWrap != YGWrapNoWrap;

  const float mainAxisownerSize = isMainAxisRow ? ownerWidth : ownerHeight;
  const float crossAxisownerSize = isMainAxisRow ? ownerHeight : ownerWidth;

  // 获取 padding & border 等，然后获得实际宽高（不是主轴交叉轴）最大 & 最小尺寸限制
  const float minInnerWidth = YGResolveValue(node->getStyle().minDimensions[YGDimensionWidth], ownerWidth)
                                        .unwrap() - paddingAndBorderAxisRow;
  const float maxInnerWidth = YGResolveValue(node->getStyle().maxDimensions[YGDimensionWidth], ownerWidth)
                                        .unwrap() - paddingAndBorderAxisRow;
  ... 

  const float minInnerMainDim = isMainAxisRow ? minInnerWidth : minInnerHeight;
  const float maxInnerMainDim = isMainAxisRow ? maxInnerWidth : maxInnerHeight;

  // STEP 2: 获取主轴 & 交叉轴上的可用空间
  // 除去边框边距外的剩余空间
  float availableInnerWidth = YGNodeCalculateAvailableInnerDim(node, YGFlexDirectionRow, 
                                                               availableWidth, ownerWidth);
  float availableInnerHeight = YGNodeCalculateAvailableInnerDim(node, YGFlexDirectionColumn, 
                                                                availableHeight, ownerHeight);

  // 换算成主轴交叉轴的可用空间
  float availableInnerMainDim = isMainAxisRow ? availableInnerWidth : availableInnerHeight;
  const float availableInnerCrossDim = isMainAxisRow ? availableInnerHeight : availableInnerWidth;

  // STEP 3: 确定每个子节点的原始内容尺寸，相当于 flex-basis
  // 这个函数里面也会递归调用 YGLayoutNodeInternal，对子节点里的子节点（孙子节点）进行测量，不进行排版
  float totalOuterFlexBasis = YGNodeComputeFlexBasisForChildren(...);

  // 是否总计算的 flex-basis 和会超过可用空间
  const bool flexBasisOverflows = measureModeMainDim == YGMeasureModeUndefined ? false 
                                          : totalOuterFlexBasis > availableInnerMainDim;

  // 如果有换行 wrap 属性，子节点需要空间超过可用空间，同时测量模式是最大值限制模式，
  // 这种时候可以按最大值的确切模式去计算子节点空间
  if (isNodeFlexWrap && flexBasisOverflows && measureModeMainDim == YGMeasureModeAtMost) {
    measureModeMainDim = YGMeasureModeExactly;
  }

  // STEP 4: 对子节点进行线性排列
  uint32_t startOfLineIndex = 0;    // 每一行的起始下标
  uint32_t endOfLineIndex = 0;        // 每一行的终点下标
  uint32_t lineCount = 0;           // 行数
  float totalLineCrossDim = 0;      // 交叉轴所有行累计占用尺寸
  float maxLineMainDim = 0;        // 主轴上占用的最大的行尺寸

  // YGCollectFlexItemsRowValues 是用来保存 STEP 4 的计算数据 model。为了便于理解，我把这个 struct 内容注释下
  // @params itemsOnLine: flex项目一行可以容纳的项目数，会考虑到可用的内部尺寸、flex 项目的 flexBasis 以及其边距等等
  // @params sizeConsumedOnCurrentLine: 当前行的所有子项的尺寸与边距累计，用于设置节点尺寸或者计算子项目剩余空间
  // @params remainingFreeSpace: 剩余可用空间
  // @params totalFlexGrowFactors: 将要放置在当前行的 flex 项目总的 flexGrow(拉伸) 因子
  // @params totalFlexShrinkFactors: 将要放置在当前行的 flex 项目总的 flexShrink(收缩) 因子
  // @params endOfLineIndex: 检查最后一个 flex 项目的结束索引（可能不是当前行，因为可能是绝对定位等）
  // @params relativeChildren: vector 可以收缩和拉伸的子节点列表
  // @params mainDim: 考虑到弹性项目的大小，填充，边距和边框后，该行的大小。
  //                  遍历所有行以确定所有者的主轴尺寸后，可用于计算maxLineDim。
  // @params crossDim: 同上
  YGCollectFlexItemsRowValues collectedFlexItemsValues;

  // 遍历所有行，当一行的空间被填满，则循环计算下一行
  for (; endOfLineIndex < childCount; lineCount++, startOfLineIndex = endOfLineIndex) {
      // 遍历 node 以及子节点，生成 YGCollectFlexItemsRowValues 数据
    collectedFlexItemsValues = YGCalculateCollectFlexItemsRowValues(...);
    endOfLineIndex = collectedFlexItemsValues.endOfLineIndex;

    // 如果不需要排版子节点，且测量模式是确切的，可以跳过整个 flex 步骤
    const bool canSkipFlex = !performLayout && measureModeCrossDim == YGMeasureModeExactly;

    // STEP 5: 解决主轴的 flexible 长度
    // 计算需要分配的剩余可用空间，如果主轴上长度未知，则按行的长度进行分配，即没有更多剩余空间可以去分配

    // 如果无法测量确切主轴占宽，则需要确保用到的行宽不会打破主轴最大 & 最小值限制
    if (measureModeMainDim != YGMeasureModeExactly) {
      ...
    }

      // 如果空间能确定，减去可能占用的宽度，获得行的剩余空间
    if (!sizeBasedOnContent && !YGFloatIsUndefined(availableInnerMainDim)) {
      collectedFlexItemsValues.remainingFreeSpace = availableInnerMainDim 
                                                      - collectedFlexItemsValues.sizeConsumedOnCurrentLine;
    }
    // availableInnerMainDim是不确定的，这意味着将根据子节点确定节点的大小。 
    // sizeConsumedOnCurrentLine为负，这意味着节点只能占据 0。因此，剩余的空间为 0 - sizeConsumedOnCurrentLine。 
    else if (collectedFlexItemsValues.sizeConsumedOnCurrentLine < 0) {
      collectedFlexItemsValues.remainingFreeSpace = -collectedFlexItemsValues.sizeConsumedOnCurrentLine;
    }

    // 如果不能跳过 flex 步骤，那需要计算下节点剩余的 flexible 宽度
    if (!canSkipFlex) {
      YGResolveFlexibleLength(...);
    }

    node->setLayoutHadOverflow(node->getLayout().hadOverflow 
                                | (collectedFlexItemsValues.remainingFreeSpace < 0));

    // STEP 6: 确定主轴以及交叉轴尺寸
    // 在这里所有的子节点在主轴上应该都有了尺寸，交叉轴上的尺寸应该也是确定了，除了 aglin 属性为 ‘stretch’ 的节点。
    // 接下来就需要计算那些属性为‘stretch’的节点，并设置最终的位置

    // 这个函数是用来计算横轴方向上子节点的位置，尺寸已经知道了，
    // 剩余空间也知道了，那就剩下根据实际属性进行空间分配了
    YGJustifyMainAxis(...);

    float containerCrossAxis = availableInnerCrossDim;
    if (measureModeCrossDim == YGMeasureModeUndefined ||
        measureModeCrossDim == YGMeasureModeAtMost) {
      // 根据子节点最大的尺寸去计算交叉轴尺寸
      containerCrossAxis = YGNodeBoundAxis(...) - paddingAndBorderAxisCross;
    }

    // 如果没有需要换行的 'flex-wrap' 属性，那交叉轴的尺寸由容器决定
    if (!isNodeFlexWrap && measureModeCrossDim == YGMeasureModeExactly) {
      collectedFlexItemsValues.crossDim = availableInnerCrossDim;
    }

    // 缩紧到容器指定的最大/最小尺寸
    collectedFlexItemsValues.crossDim = YGNodeBoundAxis(...) - paddingAndBorderAxisCross;

    // STEP 7: 交叉轴对齐
    // 如果只是测量容器，可以跳过子节点对齐。否则循环去计算子节点的横轴位置尺寸
    if (performLayout) {
      for (uint32_t i = startOfLineIndex; i < endOfLineIndex; i++) {
        const YGNodeRef child = node->getChild(i);
        if (child->getStyle().display == YGDisplayNone) {
          continue;
        }
        if (child->getStyle().positionType == YGPositionTypeAbsolute) {
          // 如果子节点是绝对布局属性，也有坐标设置，则直接覆盖掉之前的所有计算
          ...
          // 如果未定义坐标或者计算结果为 NAN，则默认为 border + margin
          if (!isChildLeadingPosDefined || Y
              GFloatIsUndefined(child->getLayout().position[pos[crossAxis]])) {
            child->setLayoutPosition(...);
          }
        }
        // flex 子节点 
        else {
          float leadingCrossDim = leadingPaddingAndBorderCross;
          // 相对布局的子节点，根据 alignItems 或者 alignSelf 来确定在交叉轴上的位置
          const YGAlign alignItem = YGNodeAlignItem(node, child);

          // 如果子节点 align = 'stretch', 则再布置一次，强制尺寸为当前交叉轴行尺寸
          if (alignItem == YGAlignStretch 
                  && child->marginLeadingValue(crossAxis).unit != YGUnitAuto 
                  && child->marginTrailingValue(crossAxis).unit != YGUnitAuto) {
            // 如果子节点定义了确切大小，则不需要根据 stretch 拉伸
            if (!YGNodeIsStyleDimDefined(child, crossAxis, availableInnerCrossDim)) {
              float childMainSize = child->getLayout().measuredDimensions[dim[mainAxis]];
              float childCrossSize = !child->getStyle().aspectRatio.isUndefined() 
                        ? child->getMarginForAxis(crossAxis, availableInnerWidth).unwrap() 
                                + (isMainAxisRow ? childMainSize / child->getStyle().aspectRatio.unwrap() 
                                        : childMainSize * child->getStyle().aspectRatio.unwrap())
                              : collectedFlexItemsValues.crossDim;

              childMainSize += child->getMarginForAxis(mainAxis, availableInnerWidth).unwrap();

              // 主轴与交叉轴约束
              YGConstrainMaxSizeForMode(..., mainAxis, YGMeasureModeExactly);
              YGConstrainMaxSizeForMode(... , crossAxis, YGMeasureModeExactly);

              // 获得子节点的约束尺寸后，判断子节点的测量模式，再去测量子节点尺寸
              const float childWidth = isMainAxisRow ? childMainSize : childCrossSize;
              const float childHeight = !isMainAxisRow ? childMainSize : childCrossSize;

              auto alignContent = node->getStyle().alignContent;
              auto crossAxisDoesNotGrow = alignContent != YGAlignStretch && isNodeFlexWrap;
              const YGMeasureMode childWidthMeasureMode =
                  YGFloatIsUndefined(childWidth) || (!isMainAxisRow && crossAxisDoesNotGrow)
                  ? YGMeasureModeUndefined : YGMeasureModeExactly;
              const YGMeasureMode childHeightMeasureMode =
                  YGFloatIsUndefined(childHeight) || (isMainAxisRow && crossAxisDoesNotGrow)
                  ? YGMeasureModeUndefined : YGMeasureModeExactly;

              // 走到这里，就调用上一个函数，再以子节点为父节点去计算子节点以下的布局了。
              // 注意 align 属性为 stretch
              YGLayoutNodeInternal(...);
            }
          } else {
              // 如果不需要拉伸节点横轴，则根据 align 属性去计算坐标即可了
        }
      }
    }

    totalLineCrossDim += collectedFlexItemsValues.crossDim;
    maxLineMainDim = YGFloatMax(maxLineMainDim, collectedFlexItemsValues.mainDim);
  }

  // STEP 8: 多行内容的对齐排版
  // 好长这里，不过也跟 STEP 7 是类似的，先获得行宽，再一个个去排列
  if (performLayout && (isNodeFlexWrap || YGIsBaselineLayout(node))) {
    // ...
  }

  // STEP 9: 计算最终的尺寸
  // 根据测量结果加 padding / margin 一类获得最终测量尺寸
  node->setLayoutMeasuredDimension(YGNodeBoundAxis(...), YGDimensionWidth);
  node->setLayoutMeasuredDimension(YGNodeBoundAxis(...), YGDimensionHeight);

  // 如果节点未指定宽高，则由子节点确定尺寸
  // 如果未指定宽高或者有最大限制
  if (measureModeMainDim == YGMeasureModeUndefined ||
      (node->getStyle().overflow != YGOverflowScroll &&
       measureModeMainDim == YGMeasureModeAtMost)) {
    // 大小限制到最大/最小值，确保不会小于 padding+border
       ...
  } else if (
      measureModeMainDim == YGMeasureModeAtMost &&
      node->getStyle().overflow == YGOverflowScroll) {
    node->setLayoutMeasuredDimension(
        YGFloatMax(
            YGFloatMin(availableInnerMainDim + paddingAndBorderAxisMain, 
                      YGNodeBoundAxisWithinMinAndMax(...).unwrap()), 
                      paddingAndBorderAxisMain),
              dim[mainAxis]);
  }

  // 确定交叉轴上的，代码跟上面的基本一致，只是换成计算交叉轴方向
  ...

  // 因为上述的对齐计算是按正常方向的 wrap 处理，如果是 'wrap-reserse' 的需要遍历子节点反转坐标处理
  if (performLayout && node->getStyle().flexWrap == YGWrapWrapReverse) {
      for (uint32_t i = 0; i < childCount; i++) { ... }
  }

  // 如果是排版流程
  if (performLayout) {
    // STEP 10: 对绝对布局的节点进行设置定位跟尺寸
    for (auto child : node->getChildren()) {
      if (child->getStyle().positionType != YGPositionTypeAbsolute) {
        continue;
      }
      YGNodeAbsoluteLayoutChild(...);
    }

    // STEP 11: 如果 flex 方向是 reverse 的，需要反向重设下节点的位置。
    //因为之前的计算方式都是按从左到右或者自上而下的方式，否则按常规方向处理。
    const bool needsMainTrailingPos = mainAxis == YGFlexDirectionRowReverse 
                                      || mainAxis == YGFlexDirectionColumnReverse;
    const bool needsCrossTrailingPos = crossAxis == YGFlexDirectionRowReverse 
                                        || crossAxis == YGFlexDirectionColumnReverse;

    if (needsMainTrailingPos || needsCrossTrailingPos) {
      for (uint32_t i = 0; i < childCount; i++) {
          ...
        if (needsMainTrailingPos) { YGNodeSetChildTrailingPosition(node, child, mainAxis); }
        if (needsCrossTrailingPos) { YGNodeSetChildTrailingPosition(node, child, crossAxis); }
      }
    }
  }
}

// Yoga 中设置的值为一个结构体，表示单位数值，包含了数值 value，和数值的单位
typedef struct YGValue {
  float value;
  YGUnit unit;
} YGValue;

// 获取项目的宽高尺寸，一般使用设置的宽高。如果最大值和最小值设置并相等，这使用该值作为尺寸。
static inline void YGResolveDimensions(YGNodeRef node) {
  for (YGDimension dim = YGDimensionWidth; dim <= YGDimensionHeight; dim++) {
    if (node->style.maxDimensions[dim].unit != YGUnitUndefined &&
        YGValueEqual(node->style.maxDimensions[dim], node->style.minDimensions[dim])) {
      node->resolvedDimensions[dim] = &node->style.maxDimensions[dim];
    } else {
      node->resolvedDimensions[dim] = &node->style.dimensions[dim];
    }
  }
}

// 根据单位算出真实值
static inline float YGResolveValue(const YGValue *const value, const float parentSize) {
  switch (value->unit) {
    case YGUnitUndefined:
    case YGUnitAuto:
      return YGUndefined; // 未定义
    case YGUnitPoint:
      return value->value; // 本身设置的值
    case YGUnitPercent:
      return value->value * parentSize / 100.0f; // 根据父亲百分比设置
  }
  return YGUndefined;
}

// 判断项目的在 style 中设置的尺寸是否是确切的，确切代表，单位不应该是 YGAuto 或 YGUndefined；如果单位
// 是 YGPoint，数值不能是负数；如果单位是百分比，数值也不能是负数。
static inline bool YGNodeIsStyleDimDefined(const YGNodeRef node,
                                           const YGFlexDirection axis,
                                           const float parentSize) {
  return !(node->resolvedDimensions[dim[axis]]->unit == YGUnitAuto ||
           node->resolvedDimensions[dim[axis]]->unit == YGUnitUndefined ||
           (node->resolvedDimensions[dim[axis]]->unit == YGUnitPoint &&
            node->resolvedDimensions[dim[axis]]->value < 0.0f) ||
           (node->resolvedDimensions[dim[axis]]->unit == YGUnitPercent &&
            (node->resolvedDimensions[dim[axis]]->value < 0.0f || YGFloatIsUndefined(parentSize))));
}

// 排版入口
void YGNodeCalculateLayout(const YGNodeRef node,
                           const float parentWidth,
                           const float parentHeight,
                           const YGDirection parentDirection) {
  // 每一次进入 Yoga 的排版，这个值都自增并且被设置给每个项目，主要用于确保 dirty 的项目在父容器给定
  // 空间不变时，只会被递归遍历一次。另外因为有些情况会略过子项目的大小测量或排版，例如当父项目宽度最大值为
  // 0，在测量的时候就会被略过。后面可以理解到该属性的作用。
  gCurrentGenerationCount++;
  // 获取项目的尺寸
  YGResolveDimensions(node);

  // 确定宽度和宽度的模式
  float width = YGUndefined;
  YGMeasureMode widthMeasureMode = YGMeasureModeUndefined;

  if (YGNodeIsStyleDimDefined(node, YGFlexDirectionRow, parentWidth)) {
    // 如果项目的尺寸是确切的，则根据单位获取确切的大小，dim[YGFlexDirectionRow]=YGDimensionWidth
    // 这里加上 margin 是要确保 availableWidth 是盒子的宽度。
    width = YGResolveValue(node->resolvedDimensions[dim[YGFlexDirectionRow]], parentWidth) 
                  + YGNodeMarginForAxis(node, YGFlexDirectionRow, parentWidth);

    // 此处的尺寸模式为确切
    widthMeasureMode = YGMeasureModeExactly;
  } else if (YGResolveValue(&node->style.maxDimensions[YGDimensionWidth], parentWidth) >= 0.0f) {
    // 如果项目的尺寸不是确切的，但是具有最大值，则取最大值。
    width = YGResolveValue(&node->style.maxDimensions[YGDimensionWidth], parentWidth);
    // 尺寸模式为有最大值限制
    widthMeasureMode = YGMeasureModeAtMost;
  } else {
    // 如果以上两个条件都没有，宽度则使用父亲给定的宽度，项目的大小交由后续自身属性或孩子来决定。
    width = parentWidth;
    // 如果父亲尺寸为确定值，则尺寸模式为确切，否则尺寸模式为未知
    widthMeasureMode = YGFloatIsUndefined(width) ? YGMeasureModeUndefined : YGMeasureModeExactly;
  }

  // 确定高度和高度尺寸的模式，和上述的宽度同理，代码也是类似，可自行对比。
  float height = YGUndefined;
  YGMeasureMode heightMeasureMode = YGMeasureModeUndefined;

  if (YGNodeIsStyleDimDefined(node, YGFlexDirectionColumn, parentHeight)) {
    height = YGResolveValue(node->resolvedDimensions[dim[YGFlexDirectionColumn]], parentHeight) +
             YGNodeMarginForAxis(node, YGFlexDirectionColumn, parentWidth);
    heightMeasureMode = YGMeasureModeExactly;
  } else if (YGResolveValue(&node->style.maxDimensions[YGDimensionHeight], parentHeight) >= 0.0f) {
    height = YGResolveValue(&node->style.maxDimensions[YGDimensionHeight], parentHeight);
    heightMeasureMode = YGMeasureModeAtMost;
  } else {
    height = parentHeight;
    heightMeasureMode = YGFloatIsUndefined(height) ? YGMeasureModeUndefined : YGMeasureModeExactly;
  }

  // 进入下一个环节
  if (YGLayoutNodeInternal(node,
                           width,
                           height,
                           parentDirection,
                           widthMeasureMode,
                           heightMeasureMode,
                           parentWidth,
                           parentHeight,
                           true,
                           "initial",
                           node->config)) {

    // 当所有节点都递归排版完毕，设置自身的位置
    YGNodeSetPosition(node, node->layout.direction, parentWidth, parentHeight, parentWidth);
    // 递归将所有节点的排版信息包括大小和位置均进行四舍五入，这里有很大学问
    YGRoundToPixelGrid(node, node->config->pointScaleFactor, 0.0f, 0.0f);

    if (gPrintTree) {
      YGNodePrint(node, YGPrintOptionsLayout | YGPrintOptionsChildren | YGPrintOptionsStyle);
    }
  }
}

// 递归将所有节点的排版信息包括大小和位置均进行四舍五入
static void YGRoundToPixelGrid(const YGNodeRef node,
                               const float pointScaleFactor,
                               const float absoluteLeft,
                               const float absoluteTop) {
  if (pointScaleFactor == 0.0f) {
    return;
  }

  const float nodeLeft = node->layout.position[YGEdgeLeft];
  const float nodeTop = node->layout.position[YGEdgeTop];

  const float nodeWidth = node->layout.dimensions[YGDimensionWidth];
  const float nodeHeight = node->layout.dimensions[YGDimensionHeight];

  const float absoluteNodeLeft = absoluteLeft + nodeLeft;
  const float absoluteNodeTop = absoluteTop + nodeTop;

  const float absoluteNodeRight = absoluteNodeLeft + nodeWidth;
  const float absoluteNodeBottom = absoluteNodeTop + nodeHeight;

  // 如果自身拥有测量的方法，则不进行四舍五入，而是强行向上取整
  const bool textRounding = node->nodeType == YGNodeTypeText;

  node->layout.position[YGEdgeLeft] =
      YGRoundValueToPixelGrid(nodeLeft, pointScaleFactor, false, textRounding);
  node->layout.position[YGEdgeTop] =
      YGRoundValueToPixelGrid(nodeTop, pointScaleFactor, false, textRounding);

  // 根据排版值最终确定大小，而不是直接强行强转测量大小
  // 这里有一个场景，例如 父亲宽 200px，横向排版，具有三个 flex:1 的孩子，均分后的孩子宽度为
  // 如果强行转测量大小，则孩子宽度为67、67、66，这就会出现和 web 不一样的结果，而按照这里的做法
  // 则是67、66、67.
  node->layout.dimensions[YGDimensionWidth] =
      YGRoundValueToPixelGrid(absoluteNodeRight, pointScaleFactor, textRounding, false) -
      YGRoundValueToPixelGrid(absoluteNodeLeft, pointScaleFactor, false, textRounding);
  node->layout.dimensions[YGDimensionHeight] =
      YGRoundValueToPixelGrid(absoluteNodeBottom, pointScaleFactor, textRounding, false) -
      YGRoundValueToPixelGrid(absoluteNodeTop, pointScaleFactor, false, textRounding);

  const uint32_t childCount = YGNodeListCount(node->children);
  for (uint32_t i = 0; i < childCount; i++) {
    YGRoundToPixelGrid(YGNodeGetChild(node, i), pointScaleFactor, absoluteNodeLeft, absoluteNodeTop);
  }
}

// 入口
bool YGLayoutNodeInternal(const YGNodeRef node,
                          const float availableWidth,
                          const float availableHeight,
                          const YGDirection parentDirection,
                          const YGMeasureMode widthMeasureMode,
                          const YGMeasureMode heightMeasureMode,
                          const float parentWidth,
                          const float parentHeight,
                          const bool performLayout,
                          const char *reason,
                          const YGConfigRef config) {
  // 获取当前项目的排版信息
  YGLayout *layout = &node->layout;

  // 深度自增，没什么用
  gDepth++;

  // 判断是否需要重新进行项目计算，条件是以下两个其中一个
  // 1.项目是脏的(需要重排)，同时在一个大排版周期中项目还未被排版过( generationCount 在这里起了判断是
  // 否排版过的作用)；2.或者父亲排版方向改变了
  const bool needToVisitNode =
      (node->isDirty && layout->generationCount != gCurrentGenerationCount) ||
      layout->lastParentDirection != parentDirection;

  // 如果需要重新进行项目，则刷新缓存的数据
  if (needToVisitNode) {
    // 用于设定在一个排版周期中缓存排版的数量，这个最大值是16，代表复杂的排版可能会被重排版次数高达16次！
    layout->nextCachedMeasurementsIndex = 0;
    layout->cachedLayout.widthMeasureMode = (YGMeasureMode) -1;
    layout->cachedLayout.heightMeasureMode = (YGMeasureMode) -1;
    layout->cachedLayout.computedWidth = -1;
    layout->cachedLayout.computedHeight = -1;
  }

  YGCachedMeasurement *cachedResults = NULL;

  // 如果外部有设置测量函数则进入 if 函数。测量是一个非常耗时的操作，比如文字测量，所以能不能从缓存中获取非常重要
  if (node->measure) {
    // 横竖向的外边距
    const float marginAxisRow = YGNodeMarginForAxis(node, YGFlexDirectionRow, parentWidth);
    const float marginAxisColumn = YGNodeMarginForAxis(node, YGFlexDirectionColumn, parentWidth);

    // 首先，判断能不能直接用当前的缓存的排版
    if (YGNodeCanUseCachedMeasurement(widthMeasureMode,
                                      availableWidth,
                                      heightMeasureMode,
                                      availableHeight,
                                      layout->cachedLayout.widthMeasureMode,
                                      layout->cachedLayout.availableWidth,
                                      layout->cachedLayout.heightMeasureMode,
                                      layout->cachedLayout.availableHeight,
                                      layout->cachedLayout.computedWidth,
                                      layout->cachedLayout.computedHeight,
                                      marginAxisRow,
                                      marginAxisColumn,
                                      config)) {
      cachedResults = &layout->cachedLayout;
    } else {
      // 将之前的缓存结果都拿出来看看是不是能用，这个能极大节省时间。
      for (uint32_t i = 0; i < layout->nextCachedMeasurementsIndex; i++) {
        if (YGNodeCanUseCachedMeasurement(widthMeasureMode,
                                          availableWidth,
                                          heightMeasureMode,
                                          availableHeight,
                                          layout->cachedMeasurements[i].widthMeasureMode,
                                          layout->cachedMeasurements[i].availableWidth,
                                          layout->cachedMeasurements[i].heightMeasureMode,
                                          layout->cachedMeasurements[i].availableHeight,
                                          layout->cachedMeasurements[i].computedWidth,
                                          layout->cachedMeasurements[i].computedHeight,
                                          marginAxisRow,
                                          marginAxisColumn,
                                          config)) {
          cachedResults = &layout->cachedMeasurements[i];
          break;
        }
      }
    }
  } else if (performLayout) {
    // 如果是需要进行排版，则判断缓存的排版是否可用，判断可用标准是父亲给定的可用宽高及其模式没有变化
    if (YGFloatsEqual(layout->cachedLayout.availableWidth, availableWidth) &&
        YGFloatsEqual(layout->cachedLayout.availableHeight, availableHeight) &&
        layout->cachedLayout.widthMeasureMode == widthMeasureMode &&
        layout->cachedLayout.heightMeasureMode == heightMeasureMode) {
      cachedResults = &layout->cachedLayout;
    }
  } else {
    // 如果不是排版而是测量，则获取缓存的测量大小，判断可用标准父亲给定的可用宽高及其模式没有变化
    for (uint32_t i = 0; i < layout->nextCachedMeasurementsIndex; i++) {
      if (YGFloatsEqual(layout->cachedMeasurements[i].availableWidth, availableWidth) &&
          YGFloatsEqual(layout->cachedMeasurements[i].availableHeight, availableHeight) &&
          layout->cachedMeasurements[i].widthMeasureMode == widthMeasureMode &&
          layout->cachedMeasurements[i].heightMeasureMode == heightMeasureMode) {
        cachedResults = &layout->cachedMeasurements[i];
        break;
      }
    }
  }

  if (!needToVisitNode && cachedResults != NULL) 
      // 如果不需要重新进行项目，同时有缓存就直接将缓存设置给 measuredDimensions (具体宽高)
    layout->measuredDimensions[YGDimensionWidth] = cachedResults->computedWidth;
    layout->measuredDimensions[YGDimensionHeight] = cachedResults->computedHeight;

    if (gPrintChanges && gPrintSkips) {
      printf("%s%d.{[skipped] ", YGSpacer(gDepth), gDepth);
      if (node->print) {
        node->print(node);
      }
      printf("wm: %s, hm: %s, aw: %f ah: %f => d: (%f, %f) %s\n",
             YGMeasureModeName(widthMeasureMode, performLayout),
             YGMeasureModeName(heightMeasureMode, performLayout),
             availableWidth,
             availableHeight,
             cachedResults->computedWidth,
             cachedResults->computedHeight,
             reason);
    }
  } else {
    if (gPrintChanges) {
      printf("%s%d.{%s", YGSpacer(gDepth), gDepth, needToVisitNode ? "*" : "");
      if (node->print) {
        node->print(node);
      }

      printf("wm: %s, hm: %s, aw: %f ah: %f %s\n",
             YGMeasureModeName(widthMeasureMode, performLayout),
             YGMeasureModeName(heightMeasureMode, performLayout),
             availableWidth,
             availableHeight,
             reason);
    }

    // 如果需要重新进行项目测量或者排版，则进入下一环节
    YGNodelayoutImpl(node,
                     availableWidth,
                     availableHeight,
                     parentDirection,
                     widthMeasureMode,
                     heightMeasureMode,
                     parentWidth,
                     parentHeight,
                     performLayout,
                     config);

    if (gPrintChanges) {
      printf("%s%d.}%s", YGSpacer(gDepth), gDepth, needToVisitNode ? "*" : "");

      if (node->print) {
        node->print(node);
      }

      printf("wm: %s, hm: %s, d: (%f, %f) %s\n",
             YGMeasureModeName(widthMeasureMode, performLayout),
             YGMeasureModeName(heightMeasureMode, performLayout),
             layout->measuredDimensions[YGDimensionWidth],
             layout->measuredDimensions[YGDimensionHeight],
             reason);
    }

      // 记录当前父容器方向
    layout->lastParentDirection = parentDirection;

    // 如果缓存为空，设置缓存
    if (cachedResults == NULL) {
      // 缓存超出了可设置大小，代表之前的都没啥用，重新记录缓存
      if (layout->nextCachedMeasurementsIndex == YG_MAX_CACHED_RESULT_COUNT) {
        if (gPrintChanges) {
          printf("Out of cache entries!\n");
        }
        layout->nextCachedMeasurementsIndex = 0;
      }

      // 获取需要更新缓存的入口，如果是排版，则获取排版单一的缓存入口，如果是测量，则获取当前指向的入口
      YGCachedMeasurement *newCacheEntry;
      if (performLayout) {
        newCacheEntry = &layout->cachedLayout;
      } else {
        newCacheEntry = &layout->cachedMeasurements[layout->nextCachedMeasurementsIndex];
        layout->nextCachedMeasurementsIndex++;
      }

        // 更新相关参数
      newCacheEntry->availableWidth = availableWidth;
      newCacheEntry->availableHeight = availableHeight;
      newCacheEntry->widthMeasureMode = widthMeasureMode;
      newCacheEntry->heightMeasureMode = heightMeasureMode;
      newCacheEntry->computedWidth = layout->measuredDimensions[YGDimensionWidth];
      newCacheEntry->computedHeight = layout->measuredDimensions[YGDimensionHeight];
    }
  }

  if (performLayout) {
    // 如果是排版则记录排版的大小，更新脏标志。
    node->layout.dimensions[YGDimensionWidth] = node->layout.measuredDimensions[YGDimensionWidth];
    node->layout.dimensions[YGDimensionHeight] = node->layout.measuredDimensions[YGDimensionHeight];
    node->hasNewLayout = true;
    node->isDirty = false;
  }

  gDepth--;
  layout->generationCount = gCurrentGenerationCount;
  // 返回 true 是排版了，false 是跳过了使用缓存。
  return (needToVisitNode || cachedResults == NULL);
}

// 判断当前缓存的测量值是否可用
bool YGNodeCanUseCachedMeasurement(const YGMeasureMode widthMode,
                                   const float width,
                                   const YGMeasureMode heightMode,
                                   const float height,
                                   const YGMeasureMode lastWidthMode,
                                   const float lastWidth,
                                   const YGMeasureMode lastHeightMode,
                                   const float lastHeight,
                                   const float lastComputedWidth,
                                   const float lastComputedHeight,
                                   const float marginRow,
                                   const float marginColumn,
                                   const YGConfigRef config) {
  if (lastComputedHeight < 0 || lastComputedWidth < 0) {
    return false;
  }

  bool useRoundedComparison = config != NULL && config->pointScaleFactor != 0;

  const float effectiveWidth = useRoundedComparison ? 
                YGRoundValueToPixelGrid(width, config->pointScaleFactor, false, false) : width;

  const float effectiveHeight = useRoundedComparison ? 
                YGRoundValueToPixelGrid(height, config->pointScaleFactor, false, false) : height;

  const float effectiveLastWidth = useRoundedComparison ? 
                YGRoundValueToPixelGrid(lastWidth, config->pointScaleFactor, false, false) : lastWidth;

  const float effectiveLastHeight = useRoundedComparison ? 
                YGRoundValueToPixelGrid(lastHeight, config->pointScaleFactor, false, false) : lastHeight;

  // 1. 判断宽高和其模式是否相等
  const bool hasSameWidthSpec = lastWidthMode == widthMode 
                                && YGFloatsEqual(effectiveLastWidth, effectiveWidth);
  const bool hasSameHeightSpec = lastHeightMode == heightMode 
                                  && YGFloatsEqual(effectiveLastHeight, effectiveHeight);

  const bool widthIsCompatible =
      hasSameWidthSpec ||
      // 2. 当前宽度模式为确切，同时缓存的计算宽度和给出的宽度是相同的。
      YGMeasureModeSizeIsExactAndMatchesOldMeasuredSize(widthMode, width - marginRow, lastComputedWidth) ||
      // 3. 当前宽度模式为最大值，缓存宽度模式为未知，同时所给可用宽度大小大于或等于缓存的计算宽度
      YGMeasureModeOldSizeIsUnspecifiedAndStillFits(widthMode,
                                                    width - marginRow,
                                                    lastWidthMode,
                                                    lastComputedWidth) ||
      // 4. 当前宽度模式和缓存宽度模式均为最大范围，缓存可用宽度值大于当前可用宽度值，同时缓存的计算宽度
      // 小于或等于当前可用宽度
      YGMeasureModeNewMeasureSizeIsStricterAndStillValid(
          widthMode, width - marginRow, lastWidthMode, lastWidth, lastComputedWidth);

  // 同宽度分析
  const bool heightIsCompatible =
      hasSameHeightSpec || YGMeasureModeSizeIsExactAndMatchesOldMeasuredSize(heightMode,
                                                                             height - marginColumn,
                                                                             lastComputedHeight) ||
      YGMeasureModeOldSizeIsUnspecifiedAndStillFits(heightMode,
                                                    height - marginColumn,
                                                    lastHeightMode,
                                                    lastComputedHeight) ||
      YGMeasureModeNewMeasureSizeIsStricterAndStillValid(
          heightMode, height - marginColumn, lastHeightMode, lastHeight, lastComputedHeight);

  // 返回宽度和高度是否仍然适用
  return widthIsCompatible && heightIsCompatible;
}

// 这个方法主要用来进行数值的四舍五入，要根据 pointScaleFactor 进行数值的四舍五入。防止直接对数值进行四
// 舍五入导致之后的换算回来有问题。简而言之根据缩放比率进行四舍五入，得到缩放比率同等级别的精度。可以保证
// 在不同大小的分辨率情况下不会出现可能左右偏移一个像素
static float YGRoundValueToPixelGrid(const float value,
                                     const float pointScaleFactor,
                                     const bool forceCeil,
                                     const bool forceFloor) {
  float fractial = fmodf(value, pointScaleFactor);
  if (YGFloatsEqual(fractial, 0)) {
    return value - fractial;
  }

  if (forceCeil) {
    return value - fractial + pointScaleFactor;
  } else if (forceFloor) {
    return value - fractial;
  } else {
    return value - fractial + (fractial >= pointScaleFactor / 2.0f ? pointScaleFactor : 0);
  }
}

// 当前宽高模式为确切，同时缓存的计算宽高和给出的宽高是相同的，代表确切值可用，返回true
static inline bool YGMeasureModeSizeIsExactAndMatchesOldMeasuredSize(YGMeasureMode sizeMode,
                                                                     float size,
                                                                     float lastComputedSize) {
  return sizeMode == YGMeasureModeExactly && YGFloatsEqual(size, lastComputedSize);
}

// 当前宽高模式为最大值，缓存宽高模式为未知，同时所给的宽高大小大于或等于缓存的宽高，
// 代表未知模式下测出来的值，在具有最大范围模式下仍然适用，返回true
static inline bool YGMeasureModeOldSizeIsUnspecifiedAndStillFits(YGMeasureMode sizeMode,
                                                                 float size,
                                                                 YGMeasureMode lastSizeMode,
                                                                 float lastComputedSize) {
  return sizeMode == YGMeasureModeAtMost && lastSizeMode == YGMeasureModeUndefined &&
         (size >= lastComputedSize || YGFloatsEqual(size, lastComputedSize));
}

// 当前宽度模式和缓存宽度模式均为最大范围，缓存可用宽度值大于当前可用宽度值，
// 同时缓存的计算宽度小于或等于当前可用宽度，当前情况宽度测量的结果必定一样，仍然适用，则返回true
static inline bool YGMeasureModeNewMeasureSizeIsStricterAndStillValid(YGMeasureMode sizeMode,
                                                                      float size,
                                                                      YGMeasureMode lastSizeMode,
                                                                      float lastSize,
                                                                      float lastComputedSize) {
  return lastSizeMode == YGMeasureModeAtMost && sizeMode == YGMeasureModeAtMost &&
         lastSize > size && (lastComputedSize <= size || YGFloatsEqual(size, lastComputedSize));
}

static void YGNodelayoutImpl(const YGNodeRef node,
                             const float availableWidth,
                             const float availableHeight,
                             const YGDirection parentDirection,
                             const YGMeasureMode widthMeasureMode,
                             const YGMeasureMode heightMeasureMode,
                             const float parentWidth,
                             const float parentHeight,
                             const bool performLayout,
                             const YGConfigRef config) {
  YGAssertWithNode(node,
                   YGFloatIsUndefined(availableWidth) ? widthMeasureMode == YGMeasureModeUndefined
                                                      : true,
                   "availableWidth is indefinite so widthMeasureMode must be "
                   "YGMeasureModeUndefined");

  YGAssertWithNode(node,
                   YGFloatIsUndefined(availableHeight) ? heightMeasureMode == YGMeasureModeUndefined
                                                       : true,
                   "availableHeight is indefinite so heightMeasureMode must be "
                   "YGMeasureModeUndefined");

  // 确定当前项目的方向，如RTL / LTR，如果是继承父亲，则使用父亲的。
  const YGDirection direction = YGNodeResolveDirection(node, parentDirection);
  node->layout.direction = direction;

  // 根据项目方向，确定横竖轴方向，如 row / row-reverse
  const YGFlexDirection flexRowDirection = YGResolveFlexDirection(YGFlexDirectionRow, direction);
  const YGFlexDirection flexColumnDirection =
      YGResolveFlexDirection(YGFlexDirectionColumn, direction);

  // 盒子模型中边界都用 edge 表示，这样在横竖轴方向可以起到泛指的作用，否则容易迷糊。比如 EdgeStart 表
  // 示起始位置，它代表 row 情况下盒子左侧，row-reverse 情况下盒子右侧。
  // 计算这些边距值时由于设置的多样性，例如 padding: 10px 10px 或者 padding: 10px。就导致了 Yoga 
  // 在处理时化成了 YGEdgeVertical 或者 YGEdgeAll 这样去判断这些值是否设置。
  node->layout.margin[YGEdgeStart] = YGNodeLeadingMargin(node, flexRowDirection, parentWidth);
  node->layout.margin[YGEdgeEnd] = YGNodeTrailingMargin(node, flexRowDirection, parentWidth);
  node->layout.margin[YGEdgeTop] = YGNodeLeadingMargin(node, flexColumnDirection, parentWidth);
  node->layout.margin[YGEdgeBottom] = YGNodeTrailingMargin(node, flexColumnDirection, parentWidth);

  node->layout.border[YGEdgeStart] = YGNodeLeadingBorder(node, flexRowDirection);
  node->layout.border[YGEdgeEnd] = YGNodeTrailingBorder(node, flexRowDirection);
  node->layout.border[YGEdgeTop] = YGNodeLeadingBorder(node, flexColumnDirection);
  node->layout.border[YGEdgeBottom] = YGNodeTrailingBorder(node, flexColumnDirection);

  node->layout.padding[YGEdgeStart] = YGNodeLeadingPadding(node, flexRowDirection, parentWidth);
  node->layout.padding[YGEdgeEnd] = YGNodeTrailingPadding(node, flexRowDirection, parentWidth);
  node->layout.padding[YGEdgeTop] = YGNodeLeadingPadding(node, flexColumnDirection, parentWidth);
  node->layout.padding[YGEdgeBottom] =
      YGNodeTrailingPadding(node, flexColumnDirection, parentWidth);

 // 当然项目设置了测量的方法，则跳转到第 5 步，然后跳出排版步骤。
 // 这里默认有测量方式的项目都不具备孩子，即无论对于测量还是排版，都不需要往后继续遍历。
 if (node->measure) {
    YGNodeWithMeasureFuncSetMeasuredDimensions(node,
                                               availableWidth,
                                               availableHeight,
                                               widthMeasureMode,
                                               heightMeasureMode,
                                               parentWidth,
                                               parentHeight);
    return;
  }

  const uint32_t childCount = YGNodeListCount(node->children);

  // 当项目的孩子数量为0时，跳转到第 6 步，然后跳出排版步骤。这里默认没有孩子的项目都不需要往后继续遍历，
  // 因为不需要为后面的孩子进行排版，只需要在这一步获得自身大小即可。
  if (childCount == 0) {
    YGNodeEmptyContainerSetMeasuredDimensions(node,
                                              availableWidth,
                                              availableHeight,
                                              widthMeasureMode,
                                              heightMeasureMode,
                                              parentWidth,
                                              parentHeight);
    return;
  }

  // 当不需要进行子项目排版，同时项目大小可以马上确定（请看第 7 步），则直接跳出排版步骤。
  if (!performLayout && YGNodeFixedSizeSetMeasuredDimensions(node,
                                                             availableWidth,
                                                             availableHeight,
                                                             widthMeasureMode,
                                                             heightMeasureMode,
                                                             parentWidth,
                                                             parentHeight)) {
    return;
  }
}