pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/yoga/yoga/node/Node.h

@@ -0,0 +1,337 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <cstdio>
+#include <vector>
+
+#include <yoga/Yoga.h>
+#include <yoga/node/LayoutableChildren.h>
+
+#include <yoga/config/Config.h>
+#include <yoga/enums/Dimension.h>
+#include <yoga/enums/Direction.h>
+#include <yoga/enums/Edge.h>
+#include <yoga/enums/Errata.h>
+#include <yoga/enums/MeasureMode.h>
+#include <yoga/enums/NodeType.h>
+#include <yoga/enums/PhysicalEdge.h>
+#include <yoga/node/LayoutResults.h>
+#include <yoga/style/Style.h>
+
+// Tag struct used to form the opaque YGNodeRef for the public C API
+struct YGNode {};
+
+namespace facebook::yoga {
+
+class YG_EXPORT Node : public ::YGNode {
+ public:
+  using LayoutableChildren = yoga::LayoutableChildren<Node>;
+  Node();
+  explicit Node(const Config* config);
+
+  Node(Node&& node) noexcept;
+
+  // Does not expose true value semantics, as children are not cloned eagerly.
+  // Should we remove this?
+  Node(const Node& node) = default;
+
+  // assignment means potential leaks of existing children, or alternatively
+  // freeing unowned memory, double free, or freeing stack memory.
+  Node& operator=(const Node&) = delete;
+
+  // Getters
+  void* getContext() const {
+    return context_;
+  }
+
+  bool alwaysFormsContainingBlock() const {
+    return alwaysFormsContainingBlock_;
+  }
+
+  bool getHasNewLayout() const {
+    return hasNewLayout_;
+  }
+
+  NodeType getNodeType() const {
+    return nodeType_;
+  }
+
+  bool hasMeasureFunc() const noexcept {
+    return measureFunc_ != nullptr;
+  }
+
+  YGSize measure(
+      float availableWidth,
+      MeasureMode widthMode,
+      float availableHeight,
+      MeasureMode heightMode);
+
+  bool hasBaselineFunc() const noexcept {
+    return baselineFunc_ != nullptr;
+  }
+
+  float baseline(float width, float height) const;
+
+  float dimensionWithMargin(FlexDirection axis, float widthSize);
+
+  bool isLayoutDimensionDefined(FlexDirection axis);
+
+  /**
+   * Whether the node has a "definite length" along the given axis.
+   * https://www.w3.org/TR/css-sizing-3/#definite
+   */
+  inline bool hasDefiniteLength(Dimension dimension, float ownerSize) {
+    auto usedValue = getProcessedDimension(dimension).resolve(ownerSize);
+    return usedValue.isDefined() && usedValue.unwrap() >= 0.0f;
+  }
+
+  bool hasErrata(Errata errata) const {
+    return config_->hasErrata(errata);
+  }
+
+  YGDirtiedFunc getDirtiedFunc() const {
+    return dirtiedFunc_;
+  }
+
+  // For Performance reasons passing as reference.
+  Style& style() {
+    return style_;
+  }
+
+  const Style& style() const {
+    return style_;
+  }
+
+  // For Performance reasons passing as reference.
+  LayoutResults& getLayout() {
+    return layout_;
+  }
+
+  const LayoutResults& getLayout() const {
+    return layout_;
+  }
+
+  size_t getLineIndex() const {
+    return lineIndex_;
+  }
+
+  bool isReferenceBaseline() const {
+    return isReferenceBaseline_;
+  }
+
+  // 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_;
+  }
+
+  const std::vector<Node*>& getChildren() const {
+    return children_;
+  }
+
+  Node* getChild(size_t index) const {
+    return children_.at(index);
+  }
+
+  size_t getChildCount() const {
+    return children_.size();
+  }
+
+  LayoutableChildren getLayoutChildren() const {
+    return LayoutableChildren(this);
+  }
+
+  size_t getLayoutChildCount() const {
+    if (contentsChildrenCount_ == 0) {
+      return children_.size();
+    } else {
+      size_t count = 0;
+      for (auto iter = getLayoutChildren().begin();
+           iter != getLayoutChildren().end();
+           iter++) {
+        count++;
+      }
+      return count;
+    }
+  }
+
+  const Config* getConfig() const {
+    return config_;
+  }
+
+  bool isDirty() const {
+    return isDirty_;
+  }
+
+  Style::Length getProcessedDimension(Dimension dimension) const {
+    return processedDimensions_[static_cast<size_t>(dimension)];
+  }
+
+  FloatOptional getResolvedDimension(
+      Direction direction,
+      Dimension dimension,
+      float referenceLength,
+      float ownerWidth) const {
+    FloatOptional value =
+        getProcessedDimension(dimension).resolve(referenceLength);
+    if (style_.boxSizing() == BoxSizing::BorderBox) {
+      return value;
+    }
+
+    FloatOptional dimensionPaddingAndBorder =
+        FloatOptional{style_.computePaddingAndBorderForDimension(
+            direction, dimension, ownerWidth)};
+
+    return value +
+        (dimensionPaddingAndBorder.isDefined() ? dimensionPaddingAndBorder
+                                               : FloatOptional{0.0});
+  }
+
+  // Setters
+
+  void setContext(void* context) {
+    context_ = context;
+  }
+
+  void setAlwaysFormsContainingBlock(bool alwaysFormsContainingBlock) {
+    alwaysFormsContainingBlock_ = alwaysFormsContainingBlock;
+  }
+
+  void setHasNewLayout(bool hasNewLayout) {
+    hasNewLayout_ = hasNewLayout;
+  }
+
+  void setNodeType(NodeType nodeType) {
+    nodeType_ = nodeType;
+  }
+
+  void setMeasureFunc(YGMeasureFunc measureFunc);
+
+  void setBaselineFunc(YGBaselineFunc baseLineFunc) {
+    baselineFunc_ = baseLineFunc;
+  }
+
+  void setDirtiedFunc(YGDirtiedFunc dirtiedFunc) {
+    dirtiedFunc_ = dirtiedFunc;
+  }
+
+  void setStyle(const Style& style) {
+    style_ = style;
+  }
+
+  void setLayout(const LayoutResults& layout) {
+    layout_ = layout;
+  }
+
+  void setLineIndex(size_t lineIndex) {
+    lineIndex_ = lineIndex;
+  }
+
+  void setIsReferenceBaseline(bool isReferenceBaseline) {
+    isReferenceBaseline_ = isReferenceBaseline;
+  }
+
+  void setOwner(Node* owner) {
+    owner_ = owner;
+  }
+
+  void setChildren(const std::vector<Node*>& children) {
+    children_ = children;
+  }
+
+  // TODO: rvalue override for setChildren
+
+  void setConfig(Config* config);
+
+  void setDirty(bool isDirty);
+  void setLayoutLastOwnerDirection(Direction direction);
+  void setLayoutComputedFlexBasis(FloatOptional computedFlexBasis);
+  void setLayoutComputedFlexBasisGeneration(
+      uint32_t computedFlexBasisGeneration);
+  void setLayoutMeasuredDimension(float measuredDimension, Dimension dimension);
+  void setLayoutHadOverflow(bool hadOverflow);
+  void setLayoutDimension(float LengthValue, Dimension dimension);
+  void setLayoutDirection(Direction direction);
+  void setLayoutMargin(float margin, PhysicalEdge edge);
+  void setLayoutBorder(float border, PhysicalEdge edge);
+  void setLayoutPadding(float padding, PhysicalEdge edge);
+  void setLayoutPosition(float position, PhysicalEdge edge);
+  void setPosition(Direction direction, float ownerWidth, float ownerHeight);
+
+  // Other methods
+  Style::Length processFlexBasis() const;
+  FloatOptional resolveFlexBasis(
+      Direction direction,
+      FlexDirection flexDirection,
+      float referenceLength,
+      float ownerWidth) const;
+  void processDimensions();
+  Direction resolveDirection(Direction ownerDirection);
+  void clearChildren();
+  /// Replaces the occurrences of oldChild with newChild
+  void replaceChild(Node* oldChild, Node* newChild);
+  void replaceChild(Node* child, size_t index);
+  void insertChild(Node* child, size_t index);
+  /// Removes the first occurrence of child
+  bool removeChild(Node* child);
+  void removeChild(size_t index);
+
+  void cloneChildrenIfNeeded();
+  void markDirtyAndPropagate();
+  float resolveFlexGrow() const;
+  float resolveFlexShrink() const;
+  bool isNodeFlexible();
+  void reset();
+
+ private:
+  // Used to allow resetting the node
+  Node& operator=(Node&&) noexcept = default;
+
+  float relativePosition(
+      FlexDirection axis,
+      Direction direction,
+      float axisSize) const;
+
+  void useWebDefaults() {
+    style_.setFlexDirection(FlexDirection::Row);
+    style_.setAlignContent(Align::Stretch);
+  }
+
+  bool hasNewLayout_ : 1 = true;
+  bool isReferenceBaseline_ : 1 = false;
+  bool isDirty_ : 1 = true;
+  bool alwaysFormsContainingBlock_ : 1 = false;
+  NodeType nodeType_ : bitCount<NodeType>() = NodeType::Default;
+  void* context_ = nullptr;
+  YGMeasureFunc measureFunc_ = nullptr;
+  YGBaselineFunc baselineFunc_ = nullptr;
+  YGDirtiedFunc dirtiedFunc_ = nullptr;
+  Style style_;
+  LayoutResults layout_;
+  size_t lineIndex_ = 0;
+  size_t contentsChildrenCount_ = 0;
+  Node* owner_ = nullptr;
+  std::vector<Node*> children_;
+  const Config* config_;
+  std::array<Style::Length, 2> processedDimensions_{
+      {StyleLength::undefined(), StyleLength::undefined()}};
+};
+
+inline Node* resolveRef(const YGNodeRef ref) {
+  return static_cast<Node*>(ref);
+}
+
+inline const Node* resolveRef(const YGNodeConstRef ref) {
+  return static_cast<const Node*>(ref);
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/numeric/Comparison.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <concepts>
+
+#include <yoga/Yoga.h>
+
+namespace facebook::yoga {
+
+constexpr bool isUndefined(std::floating_point auto value) {
+  return value != value;
+}
+
+constexpr bool isDefined(std::floating_point auto value) {
+  return !isUndefined(value);
+}
+
+/**
+ * Constexpr version of `std::isinf` before C++ 23
+ */
+constexpr bool isinf(auto value) {
+  return value == +std::numeric_limits<decltype(value)>::infinity() ||
+      value == -std::numeric_limits<decltype(value)>::infinity();
+}
+
+constexpr auto maxOrDefined(
+    std::floating_point auto a,
+    std::floating_point auto b) {
+  if (yoga::isDefined(a) && yoga::isDefined(b)) {
+    return std::max(a, b);
+  }
+  return yoga::isUndefined(a) ? b : a;
+}
+
+constexpr auto minOrDefined(
+    std::floating_point auto a,
+    std::floating_point auto b) {
+  if (yoga::isDefined(a) && yoga::isDefined(b)) {
+    return std::min(a, b);
+  }
+
+  return yoga::isUndefined(a) ? b : a;
+}
+
+// Custom equality functions using a hardcoded epsilon of 0.0001f, or returning
+// true if both floats are NaN.
+inline bool inexactEquals(float a, float b) {
+  if (yoga::isDefined(a) && yoga::isDefined(b)) {
+    return std::abs(a - b) < 0.0001f;
+  }
+  return yoga::isUndefined(a) && yoga::isUndefined(b);
+}
+
+inline bool inexactEquals(double a, double b) {
+  if (yoga::isDefined(a) && yoga::isDefined(b)) {
+    return std::abs(a - b) < 0.0001;
+  }
+  return yoga::isUndefined(a) && yoga::isUndefined(b);
+}
+
+template <std::size_t Size, typename ElementT>
+bool inexactEquals(
+    const std::array<ElementT, Size>& val1,
+    const std::array<ElementT, Size>& val2) {
+  bool areEqual = true;
+  for (std::size_t i = 0; i < Size && areEqual; ++i) {
+    areEqual = inexactEquals(val1[i], val2[i]);
+  }
+  return areEqual;
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/numeric/FloatOptional.h

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <yoga/numeric/Comparison.h>
+#include <limits>
+
+namespace facebook::yoga {
+
+struct FloatOptional {
+ private:
+  float value_ = std::numeric_limits<float>::quiet_NaN();
+
+ public:
+  explicit constexpr FloatOptional(float value) : value_(value) {}
+  constexpr FloatOptional() = default;
+
+  // returns the wrapped value, or a value x with YGIsUndefined(x) == true
+  constexpr float unwrap() const {
+    return value_;
+  }
+
+  constexpr float unwrapOrDefault(float defaultValue) const {
+    return isUndefined() ? defaultValue : value_;
+  }
+
+  constexpr bool isUndefined() const {
+    return yoga::isUndefined(value_);
+  }
+
+  constexpr bool isDefined() const {
+    return yoga::isDefined(value_);
+  }
+};
+
+// operators take FloatOptional by value, as it is a 32bit value
+
+constexpr bool operator==(FloatOptional lhs, FloatOptional rhs) {
+  return lhs.unwrap() == rhs.unwrap() ||
+      (lhs.isUndefined() && rhs.isUndefined());
+}
+constexpr bool operator!=(FloatOptional lhs, FloatOptional rhs) {
+  return !(lhs == rhs);
+}
+
+constexpr bool operator==(FloatOptional lhs, float rhs) {
+  return lhs == FloatOptional{rhs};
+}
+constexpr bool operator!=(FloatOptional lhs, float rhs) {
+  return !(lhs == rhs);
+}
+
+constexpr bool operator==(float lhs, FloatOptional rhs) {
+  return rhs == lhs;
+}
+constexpr bool operator!=(float lhs, FloatOptional rhs) {
+  return !(lhs == rhs);
+}
+
+constexpr FloatOptional operator+(FloatOptional lhs, FloatOptional rhs) {
+  return FloatOptional{lhs.unwrap() + rhs.unwrap()};
+}
+
+constexpr bool operator>(FloatOptional lhs, FloatOptional rhs) {
+  return lhs.unwrap() > rhs.unwrap();
+}
+
+constexpr bool operator<(FloatOptional lhs, FloatOptional rhs) {
+  return lhs.unwrap() < rhs.unwrap();
+}
+
+constexpr bool operator>=(FloatOptional lhs, FloatOptional rhs) {
+  return lhs > rhs || lhs == rhs;
+}
+
+constexpr bool operator<=(FloatOptional lhs, FloatOptional rhs) {
+  return lhs < rhs || lhs == rhs;
+}
+
+constexpr FloatOptional maxOrDefined(FloatOptional lhs, FloatOptional rhs) {
+  return FloatOptional{yoga::maxOrDefined(lhs.unwrap(), rhs.unwrap())};
+}
+
+inline bool inexactEquals(FloatOptional lhs, FloatOptional rhs) {
+  return yoga::inexactEquals(lhs.unwrap(), rhs.unwrap());
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/style/SmallValueBuffer.h

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <array>
+#include <bitset>
+#include <cassert>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+namespace facebook::yoga {
+
+// Container which allows storing 32 or 64 bit integer values, whose index may
+// never change. Values are first stored in a fixed buffer of `BufferSize`
+// 32-bit chunks, before falling back to heap allocation.
+template <size_t BufferSize>
+class SmallValueBuffer {
+ public:
+  SmallValueBuffer() = default;
+  SmallValueBuffer(const SmallValueBuffer& other) {
+    *this = other;
+  }
+  SmallValueBuffer(SmallValueBuffer&& other) noexcept = default;
+
+  // Add a new element to the buffer, returning the index of the element
+  uint16_t push(uint32_t value) {
+    const auto index = count_++;
+    assert(index < 4096 && "SmallValueBuffer can only hold up to 4096 chunks");
+    if (index < buffer_.size()) {
+      buffer_[index] = value;
+      return index;
+    }
+
+    if (overflow_ == nullptr) {
+      overflow_ = std::make_unique<SmallValueBuffer::Overflow>();
+    }
+
+    overflow_->buffer_.push_back(value);
+    overflow_->wideElements_.push_back(false);
+    return index;
+  }
+
+  uint16_t push(uint64_t value) {
+    const auto lsb = static_cast<uint32_t>(value & 0xFFFFFFFF);
+    const auto msb = static_cast<uint32_t>(value >> 32);
+
+    const auto lsbIndex = push(lsb);
+    [[maybe_unused]] const auto msbIndex = push(msb);
+    assert(
+        msbIndex < 4096 && "SmallValueBuffer can only hold up to 4096 chunks");
+
+    if (lsbIndex < buffer_.size()) {
+      wideElements_[lsbIndex] = true;
+    } else {
+      overflow_->wideElements_[lsbIndex - buffer_.size()] = true;
+    }
+    return lsbIndex;
+  }
+
+  // Replace an existing element in the buffer with a new value. A new index
+  // may be returned, e.g. if a new value is wider than the previous.
+  [[nodiscard]] uint16_t replace(uint16_t index, uint32_t value) {
+    if (index < buffer_.size()) {
+      buffer_[index] = value;
+    } else {
+      overflow_->buffer_.at(index - buffer_.size()) = value;
+    }
+
+    return index;
+  }
+
+  [[nodiscard]] uint16_t replace(uint16_t index, uint64_t value) {
+    const bool isWide = index < wideElements_.size()
+        ? wideElements_[index]
+        : overflow_->wideElements_.at(index - buffer_.size());
+
+    if (isWide) {
+      const auto lsb = static_cast<uint32_t>(value & 0xFFFFFFFF);
+      const auto msb = static_cast<uint32_t>(value >> 32);
+
+      [[maybe_unused]] auto lsbIndex = replace(index, lsb);
+      [[maybe_unused]] auto msbIndex = replace(index + 1, msb);
+      return index;
+    } else {
+      return push(value);
+    }
+  }
+
+  // Get a value of a given width
+  uint32_t get32(uint16_t index) const {
+    if (index < buffer_.size()) {
+      return buffer_[index];
+    } else {
+      return overflow_->buffer_.at(index - buffer_.size());
+    }
+  }
+
+  uint64_t get64(uint16_t index) const {
+    const auto lsb = get32(index);
+    const auto msb = get32(index + 1);
+    return (static_cast<uint64_t>(msb) << 32) | lsb;
+  }
+
+  SmallValueBuffer& operator=(const SmallValueBuffer& other) {
+    count_ = other.count_;
+    buffer_ = other.buffer_;
+    wideElements_ = other.wideElements_;
+    overflow_ = other.overflow_ ? std::make_unique<Overflow>(*other.overflow_)
+                                : nullptr;
+    return *this;
+  }
+
+  SmallValueBuffer& operator=(SmallValueBuffer&& other) noexcept = default;
+
+ private:
+  struct Overflow {
+    std::vector<uint32_t> buffer_;
+    std::vector<bool> wideElements_;
+  };
+
+  uint16_t count_{0};
+  std::array<uint32_t, BufferSize> buffer_{};
+  std::bitset<BufferSize> wideElements_;
+  std::unique_ptr<Overflow> overflow_;
+};
+
+} // namespace facebook::yoga