static inline MapBuffer viewPropsDiff()

in ReactAndroid/src/main/java/com/facebook/react/fabric/jni/viewPropConversions.h [262:524]

• 225 lines of code
• 57 McCabe index (conditional complexity)

static inline MapBuffer viewPropsDiff(
    ViewProps const &oldProps,
    ViewProps const &newProps) {
  MapBufferBuilder builder;
  if (oldProps.accessibilityActions != newProps.accessibilityActions) {
    builder.putMapBuffer(
        VP_ACCESSIBILITY_ACTIONS,
        convertAccessibilityActions(newProps.accessibilityActions));
  }

  if (oldProps.accessibilityHint != newProps.accessibilityHint) {
    builder.putString(VP_ACCESSIBILITY_HINT, newProps.accessibilityHint);
  }

  if (oldProps.accessibilityLabel != newProps.accessibilityLabel) {
    builder.putString(VP_ACCESSIBILITY_LABEL, newProps.accessibilityLabel);
  }

  if (oldProps.accessibilityLabelledBy != newProps.accessibilityLabelledBy) {
    builder.putMapBuffer(
        VP_ACCESSIBILITY_LABELLED_BY,
        convertAccessibilityLabelledBy(newProps.accessibilityLabelledBy));
  }

  if (oldProps.accessibilityLiveRegion != newProps.accessibilityLiveRegion) {
    int value;
    switch (newProps.accessibilityLiveRegion) {
      case AccessibilityLiveRegion::None:
        value = 0;
        break;
      case AccessibilityLiveRegion::Polite:
        value = 1;
        break;
      case AccessibilityLiveRegion::Assertive:
        value = 2;
        break;
    }
    builder.putInt(VP_ACCESSIBILITY_LIVE_REGION, value);
  }

  if (oldProps.accessibilityRole != newProps.accessibilityRole) {
    builder.putString(VP_ACCESSIBILITY_ROLE, newProps.accessibilityRole);
  }

  if (oldProps.accessibilityState != newProps.accessibilityState) {
    builder.putMapBuffer(
        VP_ACCESSIBILITY_STATE,
        convertAccessibilityState(newProps.accessibilityState));
  }

  if (oldProps.accessibilityValue != newProps.accessibilityValue) {
    builder.putString(
        VP_ACCESSIBILITY_VALUE, newProps.accessibilityValue.text.value_or(""));
  }

  if (oldProps.accessible != newProps.accessible) {
    builder.putBool(VP_ACCESSIBLE, newProps.accessible);
  }

  if (oldProps.backfaceVisibility != newProps.backfaceVisibility) {
    int value;
    switch (newProps.backfaceVisibility) {
      case BackfaceVisibility::Auto:
        value = 0;
        break;
      case BackfaceVisibility::Visible:
        value = 1;
        break;
      case BackfaceVisibility::Hidden:
        value = 2;
        break;
    }
    builder.putInt(VP_BACKFACE_VISIBILITY, value);
  }

  if (oldProps.backgroundColor != newProps.backgroundColor) {
    builder.putInt(VP_BG_COLOR, toAndroidRepr(newProps.backgroundColor));
  }

  if (oldProps.borderColors != newProps.borderColors) {
    builder.putMapBuffer(
        VP_BORDER_COLOR, convertBorderColors(newProps.borderColors));
  }

  if (oldProps.borderRadii != newProps.borderRadii) {
    builder.putMapBuffer(
        VP_BORDER_RADII, convertBorderRadii(newProps.borderRadii));
  }

  if (oldProps.borderStyles != newProps.borderStyles) {
    int value = -1;
    if (newProps.borderStyles.all.has_value()) {
      switch (newProps.borderStyles.all.value()) {
        case BorderStyle::Solid:
          value = 0;
          break;
        case BorderStyle::Dotted:
          value = 1;
          break;
        case BorderStyle::Dashed:
          value = 2;
          break;
      }
    }
    builder.putInt(VP_BORDER_STYLE, value);
  }

  if (oldProps.elevation != newProps.elevation) {
    builder.putDouble(VP_ELEVATION, newProps.elevation);
  }

#ifdef ANDROID
  if (oldProps.focusable != newProps.focusable) {
    builder.putBool(VP_FOCUSABLE, newProps.focusable);
  }

  if (oldProps.hasTVPreferredFocus != newProps.hasTVPreferredFocus) {
    builder.putBool(VP_HAS_TV_FOCUS, newProps.hasTVPreferredFocus);
  }
#endif

  if (oldProps.hitSlop != newProps.hitSlop) {
    builder.putMapBuffer(VP_HIT_SLOP, convertEdgeInsets(newProps.hitSlop));
  }

  if (oldProps.importantForAccessibility !=
      newProps.importantForAccessibility) {
    int value;
    switch (newProps.importantForAccessibility) {
      case ImportantForAccessibility::Auto:
        value = 0;
        break;
      case ImportantForAccessibility::Yes:
        value = 1;
        break;
      case ImportantForAccessibility::No:
        value = 2;
        break;
      case ImportantForAccessibility::NoHideDescendants:
        value = 3;
        break;
    }
    builder.putInt(VP_IMPORTANT_FOR_ACCESSIBILITY, value);
  }

#ifdef ANDROID
  if (oldProps.nativeBackground != newProps.nativeBackground) {
    builder.putMapBuffer(
        VP_NATIVE_BACKGROUND,
        convertNativeBackground(newProps.nativeBackground));
  }

  if (oldProps.nativeForeground != newProps.nativeForeground) {
    builder.putMapBuffer(
        VP_NATIVE_FOREGROUND,
        convertNativeBackground(newProps.nativeForeground));
  }
#endif

  if (oldProps.nativeId != newProps.nativeId) {
    builder.putString(VP_NATIVE_ID, newProps.nativeId);
  }

#ifdef ANDROID
  if (oldProps.needsOffscreenAlphaCompositing !=
      newProps.needsOffscreenAlphaCompositing) {
    builder.putBool(
        VP_OFFSCREEN_ALPHA_COMPOSITING,
        newProps.needsOffscreenAlphaCompositing);
  }
#endif

  if (oldProps.opacity != newProps.opacity) {
    builder.putDouble(VP_OPACITY, newProps.opacity);
  }

  if (oldProps.pointerEvents != newProps.pointerEvents) {
    int value;
    switch (newProps.pointerEvents) {
      case PointerEventsMode::Auto:
        value = 0;
        break;
      case PointerEventsMode::None:
        value = 1;
        break;
      case PointerEventsMode::BoxNone:
        value = 2;
        break;
      case PointerEventsMode::BoxOnly:
        value = 3;
        break;
    }

    builder.putInt(VP_POINTER_EVENTS, value);
  }

  if (oldProps.events != newProps.events) {
    builder.putBool(
        VP_POINTER_ENTER, newProps.events[ViewEvents::Offset::PointerEnter]);
    builder.putBool(
        VP_POINTER_LEAVE, newProps.events[ViewEvents::Offset::PointerLeave]);
    builder.putBool(
        VP_POINTER_MOVE, newProps.events[ViewEvents::Offset::PointerMove]);
  }

  if (oldProps.removeClippedSubviews != newProps.removeClippedSubviews) {
    builder.putBool(VP_REMOVE_CLIPPED_SUBVIEW, newProps.removeClippedSubviews);
  }

#ifdef ANDROID
  if (oldProps.renderToHardwareTextureAndroid !=
      newProps.renderToHardwareTextureAndroid) {
    builder.putBool(
        VP_RENDER_TO_HARDWARE_TEXTURE, newProps.renderToHardwareTextureAndroid);
  }
#endif

  if (oldProps.shadowColor != newProps.shadowColor) {
    builder.putInt(VP_SHADOW_COLOR, toAndroidRepr(newProps.shadowColor));
  }

  if (oldProps.testId != newProps.testId) {
    builder.putString(VP_TEST_ID, newProps.testId);
  }

  // TODO: seems like transform covers rotation/translate/scale/skew?

  if (oldProps.transform != newProps.transform) {
    builder.putMapBuffer(VP_TRANSFORM, convertTransform(newProps.transform));
  }

  if (oldProps.zIndex != newProps.zIndex) {
    builder.putInt(VP_ZINDEX, newProps.zIndex.value_or(0));
  }

  if (oldProps.yogaStyle != newProps.yogaStyle) {
    auto const &oldStyle = oldProps.yogaStyle;
    auto const &newStyle = newProps.yogaStyle;

    if (!(oldStyle.border() == newStyle.border())) {
      builder.putMapBuffer(
          YG_BORDER_WIDTH, convertBorderWidths(newStyle.border()));
    }

    if (oldStyle.overflow() != newStyle.overflow()) {
      int value;
      switch (newStyle.overflow()) {
        case YGOverflowVisible:
          value = 0;
          break;
        case YGOverflowHidden:
          value = 1;
          break;
        case YGOverflowScroll:
          value = 2;
          break;
      }
      builder.putInt(YG_OVERFLOW, value);
    }
  }

  return builder.build();
}