pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/yoga/yoga/config/Config.cpp

@@ -0,0 +1,135 @@
+/*
+ * 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.
+ */
+
+#include <yoga/config/Config.h>
+#include <yoga/debug/Log.h>
+#include <yoga/node/Node.h>
+
+namespace facebook::yoga {
+
+bool configUpdateInvalidatesLayout(
+    const Config& oldConfig,
+    const Config& newConfig) {
+  return oldConfig.getErrata() != newConfig.getErrata() ||
+      oldConfig.getEnabledExperiments() != newConfig.getEnabledExperiments() ||
+      oldConfig.getPointScaleFactor() != newConfig.getPointScaleFactor() ||
+      oldConfig.useWebDefaults() != newConfig.useWebDefaults();
+}
+
+void Config::setUseWebDefaults(bool useWebDefaults) {
+  useWebDefaults_ = useWebDefaults;
+}
+
+bool Config::useWebDefaults() const {
+  return useWebDefaults_;
+}
+
+void Config::setExperimentalFeatureEnabled(
+    ExperimentalFeature feature,
+    bool enabled) {
+  if (isExperimentalFeatureEnabled(feature) != enabled) {
+    experimentalFeatures_.set(static_cast<size_t>(feature), enabled);
+    version_++;
+  }
+}
+
+bool Config::isExperimentalFeatureEnabled(ExperimentalFeature feature) const {
+  return experimentalFeatures_.test(static_cast<size_t>(feature));
+}
+
+ExperimentalFeatureSet Config::getEnabledExperiments() const {
+  return experimentalFeatures_;
+}
+
+void Config::setErrata(Errata errata) {
+  if (errata_ != errata) {
+    errata_ = errata;
+    version_++;
+  }
+}
+
+void Config::addErrata(Errata errata) {
+  if (!hasErrata(errata)) {
+    errata_ |= errata;
+    version_++;
+  }
+}
+
+void Config::removeErrata(Errata errata) {
+  if (hasErrata(errata)) {
+    errata_ &= (~errata);
+    version_++;
+  }
+}
+
+Errata Config::getErrata() const {
+  return errata_;
+}
+
+bool Config::hasErrata(Errata errata) const {
+  return (errata_ & errata) != Errata::None;
+}
+
+void Config::setPointScaleFactor(float pointScaleFactor) {
+  if (pointScaleFactor_ != pointScaleFactor) {
+    pointScaleFactor_ = pointScaleFactor;
+    version_++;
+  }
+}
+
+float Config::getPointScaleFactor() const {
+  return pointScaleFactor_;
+}
+
+void Config::setContext(void* context) {
+  context_ = context;
+}
+
+void* Config::getContext() const {
+  return context_;
+}
+
+uint32_t Config::getVersion() const noexcept {
+  return version_;
+}
+
+void Config::setLogger(YGLogger logger) {
+  logger_ = logger;
+}
+
+void Config::log(
+    const yoga::Node* node,
+    LogLevel logLevel,
+    const char* format,
+    va_list args) const {
+  logger_(this, node, unscopedEnum(logLevel), format, args);
+}
+
+void Config::setCloneNodeCallback(YGCloneNodeFunc cloneNode) {
+  cloneNodeCallback_ = cloneNode;
+}
+
+YGNodeRef Config::cloneNode(
+    YGNodeConstRef node,
+    YGNodeConstRef owner,
+    size_t childIndex) const {
+  YGNodeRef clone = nullptr;
+  if (cloneNodeCallback_ != nullptr) {
+    clone = cloneNodeCallback_(node, owner, childIndex);
+  }
+  if (clone == nullptr) {
+    clone = YGNodeClone(node);
+  }
+  return clone;
+}
+
+/*static*/ const Config& Config::getDefault() {
+  static Config config{getDefaultLogger()};
+  return config;
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/config/Config.h

@@ -0,0 +1,92 @@
+/*
+ * 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 <bitset>
+
+#include <yoga/Yoga.h>
+#include <yoga/enums/Errata.h>
+#include <yoga/enums/ExperimentalFeature.h>
+#include <yoga/enums/LogLevel.h>
+
+// Tag struct used to form the opaque YGConfigRef for the public C API
+struct YGConfig {};
+
+namespace facebook::yoga {
+
+class Config;
+class Node;
+
+using ExperimentalFeatureSet = std::bitset<ordinalCount<ExperimentalFeature>()>;
+
+// Whether moving a node from an old to new config should dirty previously
+// calculated layout results.
+bool configUpdateInvalidatesLayout(
+    const Config& oldConfig,
+    const Config& newConfig);
+
+class YG_EXPORT Config : public ::YGConfig {
+ public:
+  explicit Config(YGLogger logger) : logger_{logger} {}
+
+  void setUseWebDefaults(bool useWebDefaults);
+  bool useWebDefaults() const;
+
+  void setExperimentalFeatureEnabled(ExperimentalFeature feature, bool enabled);
+  bool isExperimentalFeatureEnabled(ExperimentalFeature feature) const;
+  ExperimentalFeatureSet getEnabledExperiments() const;
+
+  void setErrata(Errata errata);
+  void addErrata(Errata errata);
+  void removeErrata(Errata errata);
+  Errata getErrata() const;
+  bool hasErrata(Errata errata) const;
+
+  void setPointScaleFactor(float pointScaleFactor);
+  float getPointScaleFactor() const;
+
+  void setContext(void* context);
+  void* getContext() const;
+
+  uint32_t getVersion() const noexcept;
+
+  void setLogger(YGLogger logger);
+  void log(
+      const yoga::Node* node,
+      LogLevel logLevel,
+      const char* format,
+      va_list args) const;
+
+  void setCloneNodeCallback(YGCloneNodeFunc cloneNode);
+  YGNodeRef
+  cloneNode(YGNodeConstRef node, YGNodeConstRef owner, size_t childIndex) const;
+
+  static const Config& getDefault();
+
+ private:
+  YGCloneNodeFunc cloneNodeCallback_{nullptr};
+  YGLogger logger_{};
+
+  bool useWebDefaults_ : 1 = false;
+
+  uint32_t version_ = 0;
+  ExperimentalFeatureSet experimentalFeatures_{};
+  Errata errata_ = Errata::None;
+  float pointScaleFactor_ = 1.0f;
+  void* context_ = nullptr;
+};
+
+inline Config* resolveRef(const YGConfigRef ref) {
+  return static_cast<Config*>(ref);
+}
+
+inline const Config* resolveRef(const YGConfigConstRef ref) {
+  return static_cast<const Config*>(ref);
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/debug/AssertFatal.cpp

@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+
+#include <exception>
+#include <stdexcept>
+
+#include <yoga/config/Config.h>
+#include <yoga/debug/AssertFatal.h>
+#include <yoga/debug/Log.h>
+#include <yoga/node/Node.h>
+
+namespace facebook::yoga {
+
+[[noreturn]] void fatalWithMessage(const char* message) {
+#if defined(__cpp_exceptions)
+  throw std::logic_error(message);
+#else
+  std::terminate();
+#endif
+}
+
+void assertFatal(const bool condition, const char* message) {
+  if (!condition) {
+    yoga::log(LogLevel::Fatal, "%s\n", message);
+    fatalWithMessage(message);
+  }
+}
+
+void assertFatalWithNode(
+    const yoga::Node* const node,
+    const bool condition,
+    const char* message) {
+  if (!condition) {
+    yoga::log(node, LogLevel::Fatal, "%s\n", message);
+    fatalWithMessage(message);
+  }
+}
+
+void assertFatalWithConfig(
+    const yoga::Config* const config,
+    const bool condition,
+    const char* message) {
+  if (!condition) {
+    yoga::log(config, LogLevel::Fatal, "%s\n", message);
+    fatalWithMessage(message);
+  }
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/debug/AssertFatal.h

@@ -0,0 +1,29 @@
+/*
+ * 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/Yoga.h>
+
+namespace facebook::yoga {
+
+class Node;
+class Config;
+
+[[noreturn]] void fatalWithMessage(const char* message);
+
+void assertFatal(bool condition, const char* message);
+void assertFatalWithNode(
+    const yoga::Node* node,
+    bool condition,
+    const char* message);
+void assertFatalWithConfig(
+    const yoga::Config* config,
+    bool condition,
+    const char* message);
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/debug/Log.cpp

@@ -0,0 +1,107 @@
+/*
+ * 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.
+ */
+
+#include <yoga/debug/Log.h>
+
+#ifdef ANDROID
+#include <android/log.h>
+#endif
+
+namespace facebook::yoga {
+
+namespace {
+
+void vlog(
+    const yoga::Config* config,
+    const yoga::Node* node,
+    LogLevel level,
+    const char* format,
+    va_list args) {
+  if (config == nullptr) {
+    getDefaultLogger()(nullptr, node, unscopedEnum(level), format, args);
+  } else {
+    config->log(node, level, format, args);
+  }
+}
+} // namespace
+
+void log(LogLevel level, const char* format, ...) noexcept {
+  va_list args;
+  va_start(args, format);
+  vlog(nullptr, nullptr, level, format, args);
+  va_end(args);
+}
+
+void log(
+    const yoga::Node* node,
+    LogLevel level,
+    const char* format,
+    ...) noexcept {
+  va_list args;
+  va_start(args, format);
+  vlog(
+      node == nullptr ? nullptr : node->getConfig(), node, level, format, args);
+  va_end(args);
+}
+
+void log(
+    const yoga::Config* config,
+    LogLevel level,
+    const char* format,
+    ...) noexcept {
+  va_list args;
+  va_start(args, format);
+  vlog(config, nullptr, level, format, args);
+  va_end(args);
+}
+
+YGLogger getDefaultLogger() {
+  return [](const YGConfigConstRef /*config*/,
+            const YGNodeConstRef /*node*/,
+            YGLogLevel level,
+            const char* format,
+            va_list args) -> int {
+#ifdef ANDROID
+    int androidLevel = YGLogLevelDebug;
+    switch (level) {
+      case YGLogLevelFatal:
+        androidLevel = ANDROID_LOG_FATAL;
+        break;
+      case YGLogLevelError:
+        androidLevel = ANDROID_LOG_ERROR;
+        break;
+      case YGLogLevelWarn:
+        androidLevel = ANDROID_LOG_WARN;
+        break;
+      case YGLogLevelInfo:
+        androidLevel = ANDROID_LOG_INFO;
+        break;
+      case YGLogLevelDebug:
+        androidLevel = ANDROID_LOG_DEBUG;
+        break;
+      case YGLogLevelVerbose:
+        androidLevel = ANDROID_LOG_VERBOSE;
+        break;
+    }
+    return __android_log_vprint(androidLevel, "yoga", format, args);
+#else
+    switch (level) {
+      case YGLogLevelError:
+      case YGLogLevelFatal:
+        return vfprintf(stderr, format, args);
+      case YGLogLevelWarn:
+      case YGLogLevelInfo:
+      case YGLogLevelDebug:
+      case YGLogLevelVerbose:
+      default:
+        return vprintf(format, args);
+    }
+#endif
+  };
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/debug/Log.h

@@ -0,0 +1,34 @@
+/*
+ * 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/Yoga.h>
+
+#include <yoga/config/Config.h>
+#include <yoga/enums/LogLevel.h>
+#include <yoga/node/Node.h>
+
+namespace facebook::yoga {
+
+void log(LogLevel level, const char* format, ...) noexcept;
+
+void log(
+    const yoga::Node* node,
+    LogLevel level,
+    const char* format,
+    ...) noexcept;
+
+void log(
+    const yoga::Config* config,
+    LogLevel level,
+    const char* format,
+    ...) noexcept;
+
+YGLogger getDefaultLogger();
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/enums/Align.h

@@ -0,0 +1,47 @@
+/*
+ * 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.
+ */
+
+// @generated by enums.py
+// clang-format off
+#pragma once
+
+#include <cstdint>
+#include <yoga/YGEnums.h>
+#include <yoga/enums/YogaEnums.h>
+
+namespace facebook::yoga {
+
+enum class Align : uint8_t {
+  Auto = YGAlignAuto,
+  FlexStart = YGAlignFlexStart,
+  Center = YGAlignCenter,
+  FlexEnd = YGAlignFlexEnd,
+  Stretch = YGAlignStretch,
+  Baseline = YGAlignBaseline,
+  SpaceBetween = YGAlignSpaceBetween,
+  SpaceAround = YGAlignSpaceAround,
+  SpaceEvenly = YGAlignSpaceEvenly,
+};
+
+template <>
+constexpr int32_t ordinalCount<Align>() {
+  return 9;
+}
+
+constexpr Align scopedEnum(YGAlign unscoped) {
+  return static_cast<Align>(unscoped);
+}
+
+constexpr YGAlign unscopedEnum(Align scoped) {
+  return static_cast<YGAlign>(scoped);
+}
+
+inline const char* toString(Align e) {
+  return YGAlignToString(unscopedEnum(e));
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/enums/BoxSizing.h

@@ -0,0 +1,40 @@
+/*
+ * 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.
+ */
+
+// @generated by enums.py
+// clang-format off
+#pragma once
+
+#include <cstdint>
+#include <yoga/YGEnums.h>
+#include <yoga/enums/YogaEnums.h>
+
+namespace facebook::yoga {
+
+enum class BoxSizing : uint8_t {
+  BorderBox = YGBoxSizingBorderBox,
+  ContentBox = YGBoxSizingContentBox,
+};
+
+template <>
+constexpr int32_t ordinalCount<BoxSizing>() {
+  return 2;
+}
+
+constexpr BoxSizing scopedEnum(YGBoxSizing unscoped) {
+  return static_cast<BoxSizing>(unscoped);
+}
+
+constexpr YGBoxSizing unscopedEnum(BoxSizing scoped) {
+  return static_cast<YGBoxSizing>(scoped);
+}
+
+inline const char* toString(BoxSizing e) {
+  return YGBoxSizingToString(unscopedEnum(e));
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/enums/Dimension.h

@@ -0,0 +1,40 @@
+/*
+ * 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.
+ */
+
+// @generated by enums.py
+// clang-format off
+#pragma once
+
+#include <cstdint>
+#include <yoga/YGEnums.h>
+#include <yoga/enums/YogaEnums.h>
+
+namespace facebook::yoga {
+
+enum class Dimension : uint8_t {
+  Width = YGDimensionWidth,
+  Height = YGDimensionHeight,
+};
+
+template <>
+constexpr int32_t ordinalCount<Dimension>() {
+  return 2;
+}
+
+constexpr Dimension scopedEnum(YGDimension unscoped) {
+  return static_cast<Dimension>(unscoped);
+}
+
+constexpr YGDimension unscopedEnum(Dimension scoped) {
+  return static_cast<YGDimension>(scoped);
+}
+
+inline const char* toString(Dimension e) {
+  return YGDimensionToString(unscopedEnum(e));
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/enums/Direction.h

@@ -0,0 +1,41 @@
+/*
+ * 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.
+ */
+
+// @generated by enums.py
+// clang-format off
+#pragma once
+
+#include <cstdint>
+#include <yoga/YGEnums.h>
+#include <yoga/enums/YogaEnums.h>
+
+namespace facebook::yoga {
+
+enum class Direction : uint8_t {
+  Inherit = YGDirectionInherit,
+  LTR = YGDirectionLTR,
+  RTL = YGDirectionRTL,
+};
+
+template <>
+constexpr int32_t ordinalCount<Direction>() {
+  return 3;
+}
+
+constexpr Direction scopedEnum(YGDirection unscoped) {
+  return static_cast<Direction>(unscoped);
+}
+
+constexpr YGDirection unscopedEnum(Direction scoped) {
+  return static_cast<YGDirection>(scoped);
+}
+
+inline const char* toString(Direction e) {
+  return YGDirectionToString(unscopedEnum(e));
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/enums/Display.h

@@ -0,0 +1,41 @@
+/*
+ * 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.
+ */
+
+// @generated by enums.py
+// clang-format off
+#pragma once
+
+#include <cstdint>
+#include <yoga/YGEnums.h>
+#include <yoga/enums/YogaEnums.h>
+
+namespace facebook::yoga {
+
+enum class Display : uint8_t {
+  Flex = YGDisplayFlex,
+  None = YGDisplayNone,
+  Contents = YGDisplayContents,
+};
+
+template <>
+constexpr int32_t ordinalCount<Display>() {
+  return 3;
+}
+
+constexpr Display scopedEnum(YGDisplay unscoped) {
+  return static_cast<Display>(unscoped);
+}
+
+constexpr YGDisplay unscopedEnum(Display scoped) {
+  return static_cast<YGDisplay>(scoped);
+}
+
+inline const char* toString(Display e) {
+  return YGDisplayToString(unscopedEnum(e));
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/enums/Edge.h

@@ -0,0 +1,47 @@
+/*
+ * 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.
+ */
+
+// @generated by enums.py
+// clang-format off
+#pragma once
+
+#include <cstdint>
+#include <yoga/YGEnums.h>
+#include <yoga/enums/YogaEnums.h>
+
+namespace facebook::yoga {
+
+enum class Edge : uint8_t {
+  Left = YGEdgeLeft,
+  Top = YGEdgeTop,
+  Right = YGEdgeRight,
+  Bottom = YGEdgeBottom,
+  Start = YGEdgeStart,
+  End = YGEdgeEnd,
+  Horizontal = YGEdgeHorizontal,
+  Vertical = YGEdgeVertical,
+  All = YGEdgeAll,
+};
+
+template <>
+constexpr int32_t ordinalCount<Edge>() {
+  return 9;
+}
+
+constexpr Edge scopedEnum(YGEdge unscoped) {
+  return static_cast<Edge>(unscoped);
+}
+
+constexpr YGEdge unscopedEnum(Edge scoped) {
+  return static_cast<YGEdge>(scoped);
+}
+
+inline const char* toString(Edge e) {
+  return YGEdgeToString(unscopedEnum(e));
+}
+
+} // namespace facebook::yoga