DaddyFrosty/yoga
1
0
Fork 0
Code Issues 96 Pull Requests 31 Actions Packages Projects Releases 33 Wiki Activity

Move NodeToString.cpp to benchmark and remove interal usages (#1568)

Browse Source 
Summary:
X-link: https://github.com/facebook/react-native/pull/42710

Pull Request resolved: https://github.com/facebook/yoga/pull/1568

This is no longer going to be built with normal yoga so we are going to switch to a public API

Reviewed By: NickGerleman

Differential Revision: D53141235

fbshipit-source-id: 259270a4cd91ef0dab91cefba9c41953b6340d78
This commit is contained in:
Joe Vilches
2024-02-02 15:44:23 -08:00
committed by Facebook GitHub Bot
parent 28975a6053
commit 19af9e6450
8 changed files with 271 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
yoga/algorithm/CalculateLayout.cpp
View File

@@ -26,7 +26,6 @@
#include <yoga/algorithm/TrailingPosition.h>
#include <yoga/debug/AssertFatal.h>
#include <yoga/debug/Log.h>
#include <yoga/debug/NodeToString.h>
#include <yoga/event/event.h>
#include <yoga/node/Node.h>
#include <yoga/numeric/Comparison.h>
@@ -2366,14 +2365,6 @@ void calculateLayout(
node->setPosition(
node->getLayout().direction(), ownerWidth, ownerHeight, ownerWidth);
roundLayoutResultsToPixelGrid(node, 0.0f, 0.0f);
#ifdef DEBUG
if (node->getConfig()->shouldPrintTree()) {
yoga::print(
node,
PrintOptions::Layout | PrintOptions::Children | PrintOptions::Style);
}
#endif
}
Event::publish<Event::LayoutPassEnd>(node, {&markerData});

8
yoga/config/Config.cpp
View File

@@ -32,14 +32,6 @@ bool Config::useWebDefaults() const {
return useWebDefaults_;
}
void Config::setShouldPrintTree(bool printTree) {
printTree_ = printTree;
}
bool Config::shouldPrintTree() const {
return printTree_;
}
void Config::setExperimentalFeatureEnabled(
ExperimentalFeature feature,
bool enabled) {

4
yoga/config/Config.h
View File

@@ -37,9 +37,6 @@ class YG_EXPORT Config : public ::YGConfig {
void setUseWebDefaults(bool useWebDefaults);
bool useWebDefaults() const;
void setShouldPrintTree(bool printTree);
bool shouldPrintTree() const;
void setExperimentalFeatureEnabled(ExperimentalFeature feature, bool enabled);
bool isExperimentalFeatureEnabled(ExperimentalFeature feature) const;
ExperimentalFeatureSet getEnabledExperiments() const;
@@ -74,7 +71,6 @@ class YG_EXPORT Config : public ::YGConfig {
YGLogger logger_;
bool useWebDefaults_ : 1 = false;
bool printTree_ : 1 = false;
ExperimentalFeatureSet experimentalFeatures_{};
Errata errata_ = Errata::None;

210
yoga/debug/NodeToString.cpp
View File

@@ -1,210 +0,0 @@
/*
* 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.
*/
#ifdef DEBUG
#include <stdarg.h>
#include <yoga/debug/Log.h>
#include <yoga/debug/NodeToString.h>
#include <yoga/numeric/Comparison.h>
namespace facebook::yoga {
static void indent(std::string& base, uint32_t level) {
for (uint32_t i = 0; i < level; ++i) {
base.append(" ");
}
}
static void appendFormattedString(std::string& str, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
va_list argsCopy;
va_copy(argsCopy, args);
std::vector<char> buf(1 + static_cast<size_t>(vsnprintf(NULL, 0, fmt, args)));
va_end(args);
vsnprintf(buf.data(), buf.size(), fmt, argsCopy);
va_end(argsCopy);
std::string result = std::string(buf.begin(), buf.end() - 1);
str.append(result);
}
static void appendFloatOptionalIfDefined(
std::string& base,
const std::string key,
const FloatOptional num) {
if (num.isDefined()) {
appendFormattedString(base, "%s: %g; ", key.c_str(), num.unwrap());
}
}
static void appendNumberIfNotUndefined(
std::string& base,
const std::string key,
const Style::Length& number) {
if (number.unit() != Unit::Undefined) {
if (number.unit() == Unit::Auto) {
base.append(key + ": auto; ");
} else {
std::string unit = number.unit() == Unit::Point ? "px" : "%%";
appendFormattedString(
base,
"%s: %g%s; ",
key.c_str(),
number.value().unwrap(),
unit.c_str());
}
}
}
static void appendNumberIfNotAuto(
std::string& base,
const std::string& key,
const Style::Length& number) {
if (number.unit() != Unit::Auto) {
appendNumberIfNotUndefined(base, key, number);
}
}
static void appendNumberIfNotZero(
std::string& base,
const std::string& str,
const Style::Length& number) {
if (number.unit() == Unit::Auto) {
base.append(str + ": auto; ");
} else if (!yoga::inexactEquals(number.value().unwrap(), 0)) {
appendNumberIfNotUndefined(base, str, number);
}
}
template <auto Field>
static void
appendEdges(std::string& base, const std::string& key, const Style& style) {
for (auto edge : ordinals<Edge>()) {
std::string str = key + "-" + toString(edge);
appendNumberIfNotZero(base, str, (style.*Field)(edge));
}
}
void nodeToString(
std::string& str,
const yoga::Node* node,
PrintOptions options,
uint32_t level) {
indent(str, level);
appendFormattedString(str, "<div ");
if ((options & PrintOptions::Layout) == PrintOptions::Layout) {
appendFormattedString(str, "layout=\"");
appendFormattedString(
str, "width: %g; ", node->getLayout().dimension(Dimension::Width));
appendFormattedString(
str, "height: %g; ", node->getLayout().dimension(Dimension::Height));
appendFormattedString(
str, "top: %g; ", node->getLayout().position(PhysicalEdge::Top));
appendFormattedString(
str, "left: %g;", node->getLayout().position(PhysicalEdge::Left));
appendFormattedString(str, "\" ");
}
if ((options & PrintOptions::Style) == PrintOptions::Style) {
appendFormattedString(str, "style=\"");
const auto& style = node->style();
if (style.flexDirection() != yoga::Style{}.flexDirection()) {
appendFormattedString(
str, "flex-direction: %s; ", toString(style.flexDirection()));
}
if (style.justifyContent() != yoga::Style{}.justifyContent()) {
appendFormattedString(
str, "justify-content: %s; ", toString(style.justifyContent()));
}
if (style.alignItems() != yoga::Style{}.alignItems()) {
appendFormattedString(
str, "align-items: %s; ", toString(style.alignItems()));
}
if (style.alignContent() != yoga::Style{}.alignContent()) {
appendFormattedString(
str, "align-content: %s; ", toString(style.alignContent()));
}
if (style.alignSelf() != yoga::Style{}.alignSelf()) {
appendFormattedString(
str, "align-self: %s; ", toString(style.alignSelf()));
}
appendFloatOptionalIfDefined(str, "flex-grow", style.flexGrow());
appendFloatOptionalIfDefined(str, "flex-shrink", style.flexShrink());
appendNumberIfNotAuto(str, "flex-basis", style.flexBasis());
appendFloatOptionalIfDefined(str, "flex", style.flex());
if (style.flexWrap() != yoga::Style{}.flexWrap()) {
appendFormattedString(str, "flex-wrap: %s; ", toString(style.flexWrap()));
}
if (style.overflow() != yoga::Style{}.overflow()) {
appendFormattedString(str, "overflow: %s; ", toString(style.overflow()));
}
if (style.display() != yoga::Style{}.display()) {
appendFormattedString(str, "display: %s; ", toString(style.display()));
}
appendEdges<&Style::margin>(str, "margin", style);
appendEdges<&Style::padding>(str, "padding", style);
appendEdges<&Style::border>(str, "border", style);
if (style.gap(Gutter::All).isDefined()) {
appendNumberIfNotUndefined(str, "gap", style.gap(Gutter::All));
} else {
appendNumberIfNotUndefined(str, "column-gap", style.gap(Gutter::Column));
appendNumberIfNotUndefined(str, "row-gap", style.gap(Gutter::Row));
}
appendNumberIfNotAuto(str, "width", style.dimension(Dimension::Width));
appendNumberIfNotAuto(str, "height", style.dimension(Dimension::Height));
appendNumberIfNotAuto(
str, "max-width", style.maxDimension(Dimension::Width));
appendNumberIfNotAuto(
str, "max-height", style.maxDimension(Dimension::Height));
appendNumberIfNotAuto(
str, "min-width", style.minDimension(Dimension::Width));
appendNumberIfNotAuto(
str, "min-height", style.minDimension(Dimension::Height));
if (style.positionType() != yoga::Style{}.positionType()) {
appendFormattedString(
str, "position: %s; ", toString(style.positionType()));
}
appendEdges<&Style::position>(str, "position", style);
appendFormattedString(str, "\" ");
if (node->hasMeasureFunc()) {
appendFormattedString(str, "has-custom-measure=\"true\"");
}
}
appendFormattedString(str, ">");
const size_t childCount = node->getChildCount();
if ((options & PrintOptions::Children) == PrintOptions::Children &&
childCount > 0) {
for (size_t i = 0; i < childCount; i++) {
appendFormattedString(str, "\n");
nodeToString(str, node->getChild(i), options, level + 1);
}
appendFormattedString(str, "\n");
indent(str, level);
}
appendFormattedString(str, "</div>");
}
void print(const yoga::Node* node, PrintOptions options) {
std::string str;
yoga::nodeToString(str, node, options, 0);
yoga::log(node, LogLevel::Debug, str.c_str());
}
} // namespace facebook::yoga
#endif

29
yoga/debug/NodeToString.h
View File

@@ -1,29 +0,0 @@
/*
* 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.
*/
#ifdef DEBUG
#pragma once
#include <string>
#include <yoga/enums/PrintOptions.h>
#include <yoga/node/Node.h>
namespace facebook::yoga {
void nodeToString(
std::string& str,
const yoga::Node* node,
PrintOptions options,
uint32_t level);
void print(const yoga::Node* node, PrintOptions options);
} // namespace facebook::yoga
#endif