From f9c2c27d33235bde5c82d3115ca4c5213a46ead5 Mon Sep 17 00:00:00 2001 From: Nick Gerleman Date: Wed, 13 Sep 2023 20:12:55 -0700 Subject: [PATCH] Use fbsource clang-format config Summary: This mirrors the clang-format config used by fbsource to Yoga. They are pretty similar, except for an annoying habit where Yoga's previous forced small functions in headers to be a a single line, so you would get a combination of multiline and single line functions next to each other which are hard to read. That is what motivated this change. It also enforces header ordering (yay). I don't think we have any side-effect causing headers, so this should be safe. Reviewed By: yungsters Differential Revision: D49248994 fbshipit-source-id: 66998395e7c0158ff9d9fb1bee44e8401bdd8f21 --- .clang-format | 59 ------- benchmark/YGBenchmark.c | 18 +- java/jni/LayoutContext.h | 2 +- java/jni/ScopedGlobalRef.h | 16 +- java/jni/ScopedLocalRef.h | 16 +- java/jni/YGJNI.h | 14 +- java/jni/YGJNIVanilla.cpp | 263 +++++++++++++---------------- java/jni/YGJTypesVanilla.h | 4 +- java/jni/YogaJniException.cpp | 2 +- java/jni/YogaJniException.h | 4 +- java/jni/common.cpp | 7 +- java/jni/common.h | 7 +- java/jni/corefunctions.cpp | 6 +- javascript/src/Config.h | 15 +- javascript/src/Node.cpp | 4 +- javascript/src/Node.h | 58 +++---- javascript/src/embind.cpp | 6 +- tests/CompactValueTest.cpp | 6 +- tests/EventsTest.cpp | 10 +- tests/FloatOptionalTest.cpp | 2 +- tests/NumericBitfieldTest.cpp | 6 +- tests/YGAlignBaselineTest.cpp | 4 +- tests/YGBaselineFuncTest.cpp | 8 +- tests/YGDirtiedTest.cpp | 2 +- tests/YGHadOverflowTest.cpp | 2 +- tests/YGLoggerTest.cpp | 6 +- tests/YGMeasureCacheTest.cpp | 6 +- tests/YGMeasureModeTest.cpp | 22 +-- tests/YGMeasureTest.cpp | 4 +- tests/YGRoundingFunctionTest.cpp | 4 +- tests/YGStyleAccessorsTest.cpp | 4 +- tests/util/TestUtil.cpp | 3 +- yoga/Yoga.cpp | 2 +- yoga/Yoga.h | 42 ++--- yoga/algorithm/Baseline.cpp | 1 - yoga/algorithm/CalculateLayout.cpp | 3 +- yoga/algorithm/PixelGrid.cpp | 2 +- yoga/algorithm/ResolveValue.h | 2 +- yoga/bits/EnumBitset.h | 2 +- yoga/bits/NumericBitfield.h | 2 +- yoga/config/Config.h | 10 +- yoga/debug/AssertFatal.h | 2 +- yoga/debug/Log.h | 2 +- yoga/event/event.h | 8 +- yoga/node/LayoutResults.h | 18 +- yoga/node/Node.h | 114 +++++++++---- yoga/numeric/Comparison.h | 2 +- yoga/numeric/FloatOptional.h | 12 +- yoga/style/CompactValue.h | 12 +- yoga/style/Style.cpp | 2 +- yoga/style/Style.h | 162 +++++++++++++----- 51 files changed, 521 insertions(+), 469 deletions(-) diff --git a/.clang-format b/.clang-format index d64a4072af..5451070756 100644 --- a/.clang-format +++ b/.clang-format @@ -1,61 +1,3 @@ -Language: Cpp -AccessModifierOffset: -2 -AlignAfterOpenBracket: AlwaysBreak -AlignConsecutiveAssignments: false -AlignConsecutiveDeclarations: false -AlignEscapedNewlines: Left -AlignOperands: false -AlignTrailingComments: false -AllowAllParametersOfDeclarationOnNextLine: false -AllowShortBlocksOnASingleLine: false -AllowShortCaseLabelsOnASingleLine: false -AllowShortFunctionsOnASingleLine: Inline -AllowShortIfStatementsOnASingleLine: false -AllowShortLoopsOnASingleLine: true -AlwaysBreakAfterReturnType: None -AlwaysBreakBeforeMultilineStrings: true -AlwaysBreakTemplateDeclarations: Yes -BinPackArguments: false -BinPackParameters: false -BreakBeforeBinaryOperators: false -BreakBeforeBraces: Attach -BreakBeforeTernaryOperators: true -BreakConstructorInitializers: BeforeColon -BreakInheritanceList: BeforeColon -BreakStringLiterals: true -ColumnLimit: 80 -CompactNamespaces: false -ConstructorInitializerAllOnOneLineOrOnePerLine: true -ConstructorInitializerIndentWidth: 4 -ContinuationIndentWidth: 4 -Cpp11BracedListStyle: true -DerivePointerAlignment: false -FixNamespaceComments: true -IndentCaseLabels: true -IndentPPDirectives: None -IndentWidth: 2 -IndentWrappedFunctionNames: false -MaxEmptyLinesToKeep: 1 -NamespaceIndentation: None -PenaltyReturnTypeOnItsOwnLine: 2000 -PointerAlignment: Left -ReflowComments: true -SortIncludes: false -SortUsingDeclarations: true -SpaceAfterCStyleCast: true -SpaceAfterTemplateKeyword: true -SpaceBeforeAssignmentOperators: true -SpaceBeforeCpp11BracedList: false -SpaceBeforeCtorInitializerColon: true -SpaceBeforeInheritanceColon: true -SpaceBeforeParens: ControlStatements -SpaceBeforeRangeBasedForLoopColon: true -SpaceInEmptyParentheses: false -SpacesBeforeTrailingComments: 1 -Standard: Cpp11 -UseTab: Never ---- -Language: ObjC AccessModifierOffset: -1 AlignAfterOpenBracket: AlwaysBreak AlignConsecutiveMacros: false @@ -165,4 +107,3 @@ Standard: Latest TabWidth: 8 UseCRLF: false UseTab: Never -... diff --git a/benchmark/YGBenchmark.c b/benchmark/YGBenchmark.c index 78aa2d2d6d..733db33833 100644 --- a/benchmark/YGBenchmark.c +++ b/benchmark/YGBenchmark.c @@ -17,8 +17,8 @@ #define YGBENCHMARKS(BLOCK) \ int main(int argc, char const* argv[]) { \ - (void) argc; \ - (void) argv; \ + (void)argc; \ + (void)argv; \ clock_t __start; \ clock_t __endTimes[NUM_REPETITIONS]; \ { BLOCK } \ @@ -33,8 +33,8 @@ __printBenchmarkResult(NAME, __start, __endTimes); static int __compareDoubles(const void* a, const void* b) { - double arg1 = *(const double*) a; - double arg2 = *(const double*) b; + double arg1 = *(const double*)a; + double arg2 = *(const double*)b; if (arg1 < arg2) { return -1; @@ -47,16 +47,14 @@ static int __compareDoubles(const void* a, const void* b) { return 0; } -static void __printBenchmarkResult( - char* name, - clock_t start, - clock_t* endTimes) { +static void +__printBenchmarkResult(char* name, clock_t start, clock_t* endTimes) { double timesInMs[NUM_REPETITIONS]; double mean = 0; clock_t lastEnd = start; for (uint32_t i = 0; i < NUM_REPETITIONS; i++) { timesInMs[i] = - ((double) (endTimes[i] - lastEnd)) / (double) CLOCKS_PER_SEC * 1000; + ((double)(endTimes[i] - lastEnd)) / (double)CLOCKS_PER_SEC * 1000; lastEnd = endTimes[i]; mean += timesInMs[i]; } @@ -81,7 +79,7 @@ static YGSize _measure( YGMeasureMode widthMode, float height, YGMeasureMode heightMode) { - (void) node; + (void)node; return (YGSize){ .width = widthMode == YGMeasureModeUndefined ? 10 : width, .height = heightMode == YGMeasureModeUndefined ? 10 : height, diff --git a/java/jni/LayoutContext.h b/java/jni/LayoutContext.h index 476ee82217..70ee31aaca 100644 --- a/java/jni/LayoutContext.h +++ b/java/jni/LayoutContext.h @@ -14,7 +14,7 @@ namespace facebook::yoga::vanillajni { // TODO: This should not be exported or used outside of the JNI bindings class YG_EXPORT LayoutContext { -public: + public: // Sets a context on the current thread for the duration of the Provider's // lifetime. This context should be set during the layout process to allow // layout callbacks to access context-data specific to the layout pass. diff --git a/java/jni/ScopedGlobalRef.h b/java/jni/ScopedGlobalRef.h index fa0afba27e..b563d0525f 100644 --- a/java/jni/ScopedGlobalRef.h +++ b/java/jni/ScopedGlobalRef.h @@ -56,7 +56,7 @@ class ScopedGlobalRef { std::is_same(), "ScopedGlobalRef instantiated for invalid type"); -public: + public: /** * Constructs a ScopedGlobalRef with a JNI global reference. * @@ -82,7 +82,9 @@ class ScopedGlobalRef { return *this; } - ~ScopedGlobalRef() { reset(); } + ~ScopedGlobalRef() { + reset(); + } /** * Deletes the currently held reference and reassigns a new one to the @@ -111,17 +113,21 @@ class ScopedGlobalRef { /** * Returns the underlying JNI global reference. */ - T get() const { return mGlobalRef; } + T get() const { + return mGlobalRef; + } /** * Returns true if the underlying JNI reference is not NULL. */ - operator bool() const { return mGlobalRef != NULL; } + operator bool() const { + return mGlobalRef != NULL; + } ScopedGlobalRef(const ScopedGlobalRef& ref) = delete; ScopedGlobalRef& operator=(const ScopedGlobalRef& other) = delete; -private: + private: T mGlobalRef; }; diff --git a/java/jni/ScopedLocalRef.h b/java/jni/ScopedLocalRef.h index e486e20460..6765078bbc 100644 --- a/java/jni/ScopedLocalRef.h +++ b/java/jni/ScopedLocalRef.h @@ -54,7 +54,7 @@ class ScopedLocalRef { std::is_same(), "ScopedLocalRef instantiated for invalid type"); -public: + public: /** * Constructs a ScopedLocalRef with a JNI local reference. * @@ -81,7 +81,9 @@ class ScopedLocalRef { return *this; } - ~ScopedLocalRef() { reset(); } + ~ScopedLocalRef() { + reset(); + } /** * Deletes the currently held reference and reassigns a new one to the @@ -110,17 +112,21 @@ class ScopedLocalRef { /** * Returns the underlying JNI local reference. */ - T get() const { return mLocalRef; } + T get() const { + return mLocalRef; + } /** * Returns true if the underlying JNI reference is not NULL. */ - operator bool() const { return mLocalRef != NULL; } + operator bool() const { + return mLocalRef != NULL; + } ScopedLocalRef(const ScopedLocalRef& ref) = delete; ScopedLocalRef& operator=(const ScopedLocalRef& other) = delete; -private: + private: JNIEnv* mEnv; T mLocalRef; }; diff --git a/java/jni/YGJNI.h b/java/jni/YGJNI.h index 6c6d7d5bac..489df201eb 100644 --- a/java/jni/YGJNI.h +++ b/java/jni/YGJNI.h @@ -29,7 +29,7 @@ union YGNodeContext { class YGNodeEdges { int32_t edges_; -public: + public: enum Edge { MARGIN = 1, PADDING = 2, @@ -48,14 +48,18 @@ class YGNodeEdges { YGNodeSetContext(node, context.asVoidPtr); } - bool has(Edge edge) { return (edges_ & edge) == edge; } + bool has(Edge edge) { + return (edges_ & edge) == edge; + } YGNodeEdges& add(Edge edge) { edges_ |= edge; return *this; } - int get() { return edges_; } + int get() { + return edges_; + } }; struct YogaValue { @@ -64,10 +68,10 @@ struct YogaValue { static jlong asJavaLong(const YGValue& value) { uint32_t valueBytes = 0; memcpy(&valueBytes, &value.value, sizeof valueBytes); - return ((jlong) value.unit) << 32 | valueBytes; + return ((jlong)value.unit) << 32 | valueBytes; } constexpr static jlong undefinedAsJavaLong() { - return ((jlong) YGUnitUndefined) << 32 | NAN_BYTES; + return ((jlong)YGUnitUndefined) << 32 | NAN_BYTES; } }; } // namespace diff --git a/java/jni/YGJNIVanilla.cpp b/java/jni/YGJNIVanilla.cpp index 747d937ba8..9e69b7b70a 100644 --- a/java/jni/YGJNIVanilla.cpp +++ b/java/jni/YGJNIVanilla.cpp @@ -5,16 +5,16 @@ * LICENSE file in the root directory of this source tree. */ -#include "jni.h" #include "YGJNIVanilla.h" #include -#include "YGJNI.h" -#include "common.h" -#include "YGJTypesVanilla.h" #include #include -#include "YogaJniException.h" #include "LayoutContext.h" +#include "YGJNI.h" +#include "YGJTypesVanilla.h" +#include "YogaJniException.h" +#include "common.h" +#include "jni.h" #include #include @@ -39,10 +39,8 @@ static jlong jni_YGConfigNewJNI(JNIEnv* /*env*/, jobject /*obj*/) { return reinterpret_cast(YGConfigNew()); } -static void jni_YGConfigFreeJNI( - JNIEnv* /*env*/, - jobject /*obj*/, - jlong nativePointer) { +static void +jni_YGConfigFreeJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) { const YGConfigRef config = _jlong2YGConfigRef(nativePointer); // unique_ptr will destruct the underlying global_ref, if present. auto context = std::unique_ptr>{ @@ -191,10 +189,8 @@ static void jni_YGConfigSetLoggerJNI( } } -static void jni_YGNodeDeallocateJNI( - JNIEnv* /*env*/, - jobject /*obj*/, - jlong nativePointer) { +static void +jni_YGNodeDeallocateJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) { if (nativePointer == 0) { return; } @@ -202,10 +198,8 @@ static void jni_YGNodeDeallocateJNI( YGNodeDeallocate(node); } -static void jni_YGNodeResetJNI( - JNIEnv* /*env*/, - jobject /*obj*/, - jlong nativePointer) { +static void +jni_YGNodeResetJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) { const YGNodeRef node = _jlong2YGNodeRef(nativePointer); void* context = YGNodeGetContext(node); YGNodeReset(node); @@ -269,10 +263,8 @@ static void jni_YGNodeRemoveChildJNI( _jlong2YGNodeRef(nativePointer), _jlong2YGNodeRef(childPointer)); } -static void YGTransferLayoutOutputsRecursive( - JNIEnv* env, - jobject thiz, - YGNodeRef root) { +static void +YGTransferLayoutOutputsRecursive(JNIEnv* env, jobject thiz, YGNodeRef root) { if (!YGNodeGetHasNewLayout(root)) { return; } @@ -356,7 +348,6 @@ static void jni_YGNodeCalculateLayoutJNI( jfloat height, jlongArray nativePointers, jobjectArray javaNodes) { - try { PtrJNodeMapVanilla* layoutContext = nullptr; auto map = PtrJNodeMapVanilla{}; @@ -389,10 +380,8 @@ static void jni_YGNodeCalculateLayoutJNI( } } -static void jni_YGNodeMarkDirtyJNI( - JNIEnv* /*env*/, - jobject /*obj*/, - jlong nativePointer) { +static void +jni_YGNodeMarkDirtyJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) { YGNodeMarkDirty(_jlong2YGNodeRef(nativePointer)); } @@ -403,11 +392,9 @@ static void jni_YGNodeMarkDirtyAndPropagateToDescendantsJNI( YGNodeMarkDirtyAndPropagateToDescendants(_jlong2YGNodeRef(nativePointer)); } -static jboolean jni_YGNodeIsDirtyJNI( - JNIEnv* /*env*/, - jobject /*obj*/, - jlong nativePointer) { - return (jboolean) YGNodeIsDirty(_jlong2YGNodeRef(nativePointer)); +static jboolean +jni_YGNodeIsDirtyJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) { + return (jboolean)YGNodeIsDirty(_jlong2YGNodeRef(nativePointer)); } static void jni_YGNodeCopyStyleJNI( @@ -422,7 +409,7 @@ static void jni_YGNodeCopyStyleJNI( #define YG_NODE_JNI_STYLE_PROP(javatype, type, name) \ static javatype jni_YGNodeStyleGet##name##JNI( \ JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) { \ - return (javatype) YGNodeStyleGet##name(_jlong2YGNodeRef(nativePointer)); \ + return (javatype)YGNodeStyleGet##name(_jlong2YGNodeRef(nativePointer)); \ } \ \ static void jni_YGNodeStyleSet##name##JNI( \ @@ -603,9 +590,9 @@ static jfloat jni_YGNodeStyleGetBorderJNI( jint edge) { YGNodeRef yogaNodeRef = _jlong2YGNodeRef(nativePointer); if (!YGNodeEdges{yogaNodeRef}.has(YGNodeEdges::BORDER)) { - return (jfloat) YGUndefined; + return (jfloat)YGUndefined; } - return (jfloat) YGNodeStyleGetBorder(yogaNodeRef, static_cast(edge)); + return (jfloat)YGNodeStyleGetBorder(yogaNodeRef, static_cast(edge)); } static void jni_YGNodeStyleSetBorderJNI( @@ -704,24 +691,20 @@ static void jni_YGNodeSetHasBaselineFuncJNI( hasBaselineFunc ? YGJNIBaselineFunc : nullptr); } -static void jni_YGNodePrintJNI( - JNIEnv* /*env*/, - jobject /*obj*/, - jlong nativePointer) { +static void +jni_YGNodePrintJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) { #ifdef DEBUG const YGNodeRef node = _jlong2YGNodeRef(nativePointer); YGNodePrint( node, - (YGPrintOptions) (YGPrintOptionsStyle | YGPrintOptionsLayout | YGPrintOptionsChildren)); + (YGPrintOptions)(YGPrintOptionsStyle | YGPrintOptionsLayout | YGPrintOptionsChildren)); #else - (void) nativePointer; + (void)nativePointer; #endif } -static jlong jni_YGNodeCloneJNI( - JNIEnv* /*env*/, - jobject /*obj*/, - jlong nativePointer) { +static jlong +jni_YGNodeCloneJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) { auto node = _jlong2YGNodeRef(nativePointer); const YGNodeRef clonedYogaNode = YGNodeClone(node); YGNodeSetContext(clonedYogaNode, YGNodeGetContext(node)); @@ -734,7 +717,7 @@ static jfloat jni_YGNodeStyleGetGapJNI( jobject /*obj*/, jlong nativePointer, jint gutter) { - return (jfloat) YGNodeStyleGetGap( + return (jfloat)YGNodeStyleGetGap( _jlong2YGNodeRef(nativePointer), static_cast(gutter)); } @@ -754,244 +737,242 @@ static void jni_YGNodeStyleSetGapJNI( YG_NODE_JNI_STYLE_PROP(jfloat, float, AspectRatio); static JNINativeMethod methods[] = { - {"jni_YGConfigNewJNI", "()J", (void*) jni_YGConfigNewJNI}, - {"jni_YGConfigFreeJNI", "(J)V", (void*) jni_YGConfigFreeJNI}, + {"jni_YGConfigNewJNI", "()J", (void*)jni_YGConfigNewJNI}, + {"jni_YGConfigFreeJNI", "(J)V", (void*)jni_YGConfigFreeJNI}, {"jni_YGConfigSetExperimentalFeatureEnabledJNI", "(JIZ)V", - (void*) jni_YGConfigSetExperimentalFeatureEnabledJNI}, + (void*)jni_YGConfigSetExperimentalFeatureEnabledJNI}, {"jni_YGConfigSetUseWebDefaultsJNI", "(JZ)V", - (void*) jni_YGConfigSetUseWebDefaultsJNI}, + (void*)jni_YGConfigSetUseWebDefaultsJNI}, {"jni_YGConfigSetPrintTreeFlagJNI", "(JZ)V", - (void*) jni_YGConfigSetPrintTreeFlagJNI}, + (void*)jni_YGConfigSetPrintTreeFlagJNI}, {"jni_YGConfigSetPointScaleFactorJNI", "(JF)V", - (void*) jni_YGConfigSetPointScaleFactorJNI}, - {"jni_YGConfigSetErrataJNI", "(JI)V", (void*) jni_YGConfigSetErrataJNI}, - {"jni_YGConfigGetErrataJNI", "(J)I", (void*) jni_YGConfigGetErrataJNI}, + (void*)jni_YGConfigSetPointScaleFactorJNI}, + {"jni_YGConfigSetErrataJNI", "(JI)V", (void*)jni_YGConfigSetErrataJNI}, + {"jni_YGConfigGetErrataJNI", "(J)I", (void*)jni_YGConfigGetErrataJNI}, {"jni_YGConfigSetLoggerJNI", "(JLcom/facebook/yoga/YogaLogger;)V", - (void*) jni_YGConfigSetLoggerJNI}, - {"jni_YGNodeNewJNI", "()J", (void*) jni_YGNodeNewJNI}, - {"jni_YGNodeNewWithConfigJNI", "(J)J", (void*) jni_YGNodeNewWithConfigJNI}, - {"jni_YGNodeDeallocateJNI", "(J)V", (void*) jni_YGNodeDeallocateJNI}, - {"jni_YGNodeResetJNI", "(J)V", (void*) jni_YGNodeResetJNI}, - {"jni_YGNodeInsertChildJNI", "(JJI)V", (void*) jni_YGNodeInsertChildJNI}, - {"jni_YGNodeSwapChildJNI", "(JJI)V", (void*) jni_YGNodeSwapChildJNI}, + (void*)jni_YGConfigSetLoggerJNI}, + {"jni_YGNodeNewJNI", "()J", (void*)jni_YGNodeNewJNI}, + {"jni_YGNodeNewWithConfigJNI", "(J)J", (void*)jni_YGNodeNewWithConfigJNI}, + {"jni_YGNodeDeallocateJNI", "(J)V", (void*)jni_YGNodeDeallocateJNI}, + {"jni_YGNodeResetJNI", "(J)V", (void*)jni_YGNodeResetJNI}, + {"jni_YGNodeInsertChildJNI", "(JJI)V", (void*)jni_YGNodeInsertChildJNI}, + {"jni_YGNodeSwapChildJNI", "(JJI)V", (void*)jni_YGNodeSwapChildJNI}, {"jni_YGNodeSetIsReferenceBaselineJNI", "(JZ)V", - (void*) jni_YGNodeSetIsReferenceBaselineJNI}, + (void*)jni_YGNodeSetIsReferenceBaselineJNI}, {"jni_YGNodeIsReferenceBaselineJNI", "(J)Z", - (void*) jni_YGNodeIsReferenceBaselineJNI}, + (void*)jni_YGNodeIsReferenceBaselineJNI}, {"jni_YGNodeRemoveAllChildrenJNI", "(J)V", - (void*) jni_YGNodeRemoveAllChildrenJNI}, - {"jni_YGNodeRemoveChildJNI", "(JJ)V", (void*) jni_YGNodeRemoveChildJNI}, + (void*)jni_YGNodeRemoveAllChildrenJNI}, + {"jni_YGNodeRemoveChildJNI", "(JJ)V", (void*)jni_YGNodeRemoveChildJNI}, {"jni_YGNodeCalculateLayoutJNI", "(JFF[J[Lcom/facebook/yoga/YogaNodeJNIBase;)V", - (void*) jni_YGNodeCalculateLayoutJNI}, - {"jni_YGNodeMarkDirtyJNI", "(J)V", (void*) jni_YGNodeMarkDirtyJNI}, + (void*)jni_YGNodeCalculateLayoutJNI}, + {"jni_YGNodeMarkDirtyJNI", "(J)V", (void*)jni_YGNodeMarkDirtyJNI}, {"jni_YGNodeMarkDirtyAndPropagateToDescendantsJNI", "(J)V", - (void*) jni_YGNodeMarkDirtyAndPropagateToDescendantsJNI}, - {"jni_YGNodeIsDirtyJNI", "(J)Z", (void*) jni_YGNodeIsDirtyJNI}, - {"jni_YGNodeCopyStyleJNI", "(JJ)V", (void*) jni_YGNodeCopyStyleJNI}, + (void*)jni_YGNodeMarkDirtyAndPropagateToDescendantsJNI}, + {"jni_YGNodeIsDirtyJNI", "(J)Z", (void*)jni_YGNodeIsDirtyJNI}, + {"jni_YGNodeCopyStyleJNI", "(JJ)V", (void*)jni_YGNodeCopyStyleJNI}, {"jni_YGNodeStyleGetDirectionJNI", "(J)I", - (void*) jni_YGNodeStyleGetDirectionJNI}, + (void*)jni_YGNodeStyleGetDirectionJNI}, {"jni_YGNodeStyleSetDirectionJNI", "(JI)V", - (void*) jni_YGNodeStyleSetDirectionJNI}, + (void*)jni_YGNodeStyleSetDirectionJNI}, {"jni_YGNodeStyleGetFlexDirectionJNI", "(J)I", - (void*) jni_YGNodeStyleGetFlexDirectionJNI}, + (void*)jni_YGNodeStyleGetFlexDirectionJNI}, {"jni_YGNodeStyleSetFlexDirectionJNI", "(JI)V", - (void*) jni_YGNodeStyleSetFlexDirectionJNI}, + (void*)jni_YGNodeStyleSetFlexDirectionJNI}, {"jni_YGNodeStyleGetJustifyContentJNI", "(J)I", - (void*) jni_YGNodeStyleGetJustifyContentJNI}, + (void*)jni_YGNodeStyleGetJustifyContentJNI}, {"jni_YGNodeStyleSetJustifyContentJNI", "(JI)V", - (void*) jni_YGNodeStyleSetJustifyContentJNI}, + (void*)jni_YGNodeStyleSetJustifyContentJNI}, {"jni_YGNodeStyleGetAlignItemsJNI", "(J)I", - (void*) jni_YGNodeStyleGetAlignItemsJNI}, + (void*)jni_YGNodeStyleGetAlignItemsJNI}, {"jni_YGNodeStyleSetAlignItemsJNI", "(JI)V", - (void*) jni_YGNodeStyleSetAlignItemsJNI}, + (void*)jni_YGNodeStyleSetAlignItemsJNI}, {"jni_YGNodeStyleGetAlignSelfJNI", "(J)I", - (void*) jni_YGNodeStyleGetAlignSelfJNI}, + (void*)jni_YGNodeStyleGetAlignSelfJNI}, {"jni_YGNodeStyleSetAlignSelfJNI", "(JI)V", - (void*) jni_YGNodeStyleSetAlignSelfJNI}, + (void*)jni_YGNodeStyleSetAlignSelfJNI}, {"jni_YGNodeStyleGetAlignContentJNI", "(J)I", - (void*) jni_YGNodeStyleGetAlignContentJNI}, + (void*)jni_YGNodeStyleGetAlignContentJNI}, {"jni_YGNodeStyleSetAlignContentJNI", "(JI)V", - (void*) jni_YGNodeStyleSetAlignContentJNI}, + (void*)jni_YGNodeStyleSetAlignContentJNI}, {"jni_YGNodeStyleGetPositionTypeJNI", "(J)I", - (void*) jni_YGNodeStyleGetPositionTypeJNI}, + (void*)jni_YGNodeStyleGetPositionTypeJNI}, {"jni_YGNodeStyleSetPositionTypeJNI", "(JI)V", - (void*) jni_YGNodeStyleSetPositionTypeJNI}, + (void*)jni_YGNodeStyleSetPositionTypeJNI}, {"jni_YGNodeStyleGetFlexWrapJNI", "(J)I", - (void*) jni_YGNodeStyleGetFlexWrapJNI}, + (void*)jni_YGNodeStyleGetFlexWrapJNI}, {"jni_YGNodeStyleSetFlexWrapJNI", "(JI)V", - (void*) jni_YGNodeStyleSetFlexWrapJNI}, + (void*)jni_YGNodeStyleSetFlexWrapJNI}, {"jni_YGNodeStyleGetOverflowJNI", "(J)I", - (void*) jni_YGNodeStyleGetOverflowJNI}, + (void*)jni_YGNodeStyleGetOverflowJNI}, {"jni_YGNodeStyleSetOverflowJNI", "(JI)V", - (void*) jni_YGNodeStyleSetOverflowJNI}, + (void*)jni_YGNodeStyleSetOverflowJNI}, {"jni_YGNodeStyleGetDisplayJNI", "(J)I", - (void*) jni_YGNodeStyleGetDisplayJNI}, + (void*)jni_YGNodeStyleGetDisplayJNI}, {"jni_YGNodeStyleSetDisplayJNI", "(JI)V", - (void*) jni_YGNodeStyleSetDisplayJNI}, - {"jni_YGNodeStyleGetFlexJNI", "(J)F", (void*) jni_YGNodeStyleGetFlexJNI}, - {"jni_YGNodeStyleSetFlexJNI", "(JF)V", (void*) jni_YGNodeStyleSetFlexJNI}, + (void*)jni_YGNodeStyleSetDisplayJNI}, + {"jni_YGNodeStyleGetFlexJNI", "(J)F", (void*)jni_YGNodeStyleGetFlexJNI}, + {"jni_YGNodeStyleSetFlexJNI", "(JF)V", (void*)jni_YGNodeStyleSetFlexJNI}, {"jni_YGNodeStyleGetFlexGrowJNI", "(J)F", - (void*) jni_YGNodeStyleGetFlexGrowJNI}, + (void*)jni_YGNodeStyleGetFlexGrowJNI}, {"jni_YGNodeStyleSetFlexGrowJNI", "(JF)V", - (void*) jni_YGNodeStyleSetFlexGrowJNI}, + (void*)jni_YGNodeStyleSetFlexGrowJNI}, {"jni_YGNodeStyleGetFlexShrinkJNI", "(J)F", - (void*) jni_YGNodeStyleGetFlexShrinkJNI}, + (void*)jni_YGNodeStyleGetFlexShrinkJNI}, {"jni_YGNodeStyleSetFlexShrinkJNI", "(JF)V", - (void*) jni_YGNodeStyleSetFlexShrinkJNI}, + (void*)jni_YGNodeStyleSetFlexShrinkJNI}, {"jni_YGNodeStyleGetFlexBasisJNI", "(J)J", - (void*) jni_YGNodeStyleGetFlexBasisJNI}, + (void*)jni_YGNodeStyleGetFlexBasisJNI}, {"jni_YGNodeStyleSetFlexBasisJNI", "(JF)V", - (void*) jni_YGNodeStyleSetFlexBasisJNI}, + (void*)jni_YGNodeStyleSetFlexBasisJNI}, {"jni_YGNodeStyleSetFlexBasisPercentJNI", "(JF)V", - (void*) jni_YGNodeStyleSetFlexBasisPercentJNI}, + (void*)jni_YGNodeStyleSetFlexBasisPercentJNI}, {"jni_YGNodeStyleSetFlexBasisAutoJNI", "(J)V", - (void*) jni_YGNodeStyleSetFlexBasisAutoJNI}, + (void*)jni_YGNodeStyleSetFlexBasisAutoJNI}, {"jni_YGNodeStyleGetMarginJNI", "(JI)J", - (void*) jni_YGNodeStyleGetMarginJNI}, + (void*)jni_YGNodeStyleGetMarginJNI}, {"jni_YGNodeStyleSetMarginJNI", "(JIF)V", - (void*) jni_YGNodeStyleSetMarginJNI}, + (void*)jni_YGNodeStyleSetMarginJNI}, {"jni_YGNodeStyleSetMarginPercentJNI", "(JIF)V", - (void*) jni_YGNodeStyleSetMarginPercentJNI}, + (void*)jni_YGNodeStyleSetMarginPercentJNI}, {"jni_YGNodeStyleSetMarginAutoJNI", "(JI)V", - (void*) jni_YGNodeStyleSetMarginAutoJNI}, + (void*)jni_YGNodeStyleSetMarginAutoJNI}, {"jni_YGNodeStyleGetPaddingJNI", "(JI)J", - (void*) jni_YGNodeStyleGetPaddingJNI}, + (void*)jni_YGNodeStyleGetPaddingJNI}, {"jni_YGNodeStyleSetPaddingJNI", "(JIF)V", - (void*) jni_YGNodeStyleSetPaddingJNI}, + (void*)jni_YGNodeStyleSetPaddingJNI}, {"jni_YGNodeStyleSetPaddingPercentJNI", "(JIF)V", - (void*) jni_YGNodeStyleSetPaddingPercentJNI}, + (void*)jni_YGNodeStyleSetPaddingPercentJNI}, {"jni_YGNodeStyleGetBorderJNI", "(JI)F", - (void*) jni_YGNodeStyleGetBorderJNI}, + (void*)jni_YGNodeStyleGetBorderJNI}, {"jni_YGNodeStyleSetBorderJNI", "(JIF)V", - (void*) jni_YGNodeStyleSetBorderJNI}, + (void*)jni_YGNodeStyleSetBorderJNI}, {"jni_YGNodeStyleGetPositionJNI", "(JI)J", - (void*) jni_YGNodeStyleGetPositionJNI}, + (void*)jni_YGNodeStyleGetPositionJNI}, {"jni_YGNodeStyleSetPositionJNI", "(JIF)V", - (void*) jni_YGNodeStyleSetPositionJNI}, + (void*)jni_YGNodeStyleSetPositionJNI}, {"jni_YGNodeStyleSetPositionPercentJNI", "(JIF)V", - (void*) jni_YGNodeStyleSetPositionPercentJNI}, - {"jni_YGNodeStyleGetWidthJNI", "(J)J", (void*) jni_YGNodeStyleGetWidthJNI}, - {"jni_YGNodeStyleSetWidthJNI", "(JF)V", (void*) jni_YGNodeStyleSetWidthJNI}, + (void*)jni_YGNodeStyleSetPositionPercentJNI}, + {"jni_YGNodeStyleGetWidthJNI", "(J)J", (void*)jni_YGNodeStyleGetWidthJNI}, + {"jni_YGNodeStyleSetWidthJNI", "(JF)V", (void*)jni_YGNodeStyleSetWidthJNI}, {"jni_YGNodeStyleSetWidthPercentJNI", "(JF)V", - (void*) jni_YGNodeStyleSetWidthPercentJNI}, + (void*)jni_YGNodeStyleSetWidthPercentJNI}, {"jni_YGNodeStyleSetWidthAutoJNI", "(J)V", - (void*) jni_YGNodeStyleSetWidthAutoJNI}, - {"jni_YGNodeStyleGetHeightJNI", - "(J)J", - (void*) jni_YGNodeStyleGetHeightJNI}, + (void*)jni_YGNodeStyleSetWidthAutoJNI}, + {"jni_YGNodeStyleGetHeightJNI", "(J)J", (void*)jni_YGNodeStyleGetHeightJNI}, {"jni_YGNodeStyleSetHeightJNI", "(JF)V", - (void*) jni_YGNodeStyleSetHeightJNI}, + (void*)jni_YGNodeStyleSetHeightJNI}, {"jni_YGNodeStyleSetHeightPercentJNI", "(JF)V", - (void*) jni_YGNodeStyleSetHeightPercentJNI}, + (void*)jni_YGNodeStyleSetHeightPercentJNI}, {"jni_YGNodeStyleSetHeightAutoJNI", "(J)V", - (void*) jni_YGNodeStyleSetHeightAutoJNI}, + (void*)jni_YGNodeStyleSetHeightAutoJNI}, {"jni_YGNodeStyleGetMinWidthJNI", "(J)J", - (void*) jni_YGNodeStyleGetMinWidthJNI}, + (void*)jni_YGNodeStyleGetMinWidthJNI}, {"jni_YGNodeStyleSetMinWidthJNI", "(JF)V", - (void*) jni_YGNodeStyleSetMinWidthJNI}, + (void*)jni_YGNodeStyleSetMinWidthJNI}, {"jni_YGNodeStyleSetMinWidthPercentJNI", "(JF)V", - (void*) jni_YGNodeStyleSetMinWidthPercentJNI}, + (void*)jni_YGNodeStyleSetMinWidthPercentJNI}, {"jni_YGNodeStyleGetMinHeightJNI", "(J)J", - (void*) jni_YGNodeStyleGetMinHeightJNI}, + (void*)jni_YGNodeStyleGetMinHeightJNI}, {"jni_YGNodeStyleSetMinHeightJNI", "(JF)V", - (void*) jni_YGNodeStyleSetMinHeightJNI}, + (void*)jni_YGNodeStyleSetMinHeightJNI}, {"jni_YGNodeStyleSetMinHeightPercentJNI", "(JF)V", - (void*) jni_YGNodeStyleSetMinHeightPercentJNI}, + (void*)jni_YGNodeStyleSetMinHeightPercentJNI}, {"jni_YGNodeStyleGetMaxWidthJNI", "(J)J", - (void*) jni_YGNodeStyleGetMaxWidthJNI}, + (void*)jni_YGNodeStyleGetMaxWidthJNI}, {"jni_YGNodeStyleSetMaxWidthJNI", "(JF)V", - (void*) jni_YGNodeStyleSetMaxWidthJNI}, + (void*)jni_YGNodeStyleSetMaxWidthJNI}, {"jni_YGNodeStyleSetMaxWidthPercentJNI", "(JF)V", - (void*) jni_YGNodeStyleSetMaxWidthPercentJNI}, + (void*)jni_YGNodeStyleSetMaxWidthPercentJNI}, {"jni_YGNodeStyleGetMaxHeightJNI", "(J)J", - (void*) jni_YGNodeStyleGetMaxHeightJNI}, + (void*)jni_YGNodeStyleGetMaxHeightJNI}, {"jni_YGNodeStyleSetMaxHeightJNI", "(JF)V", - (void*) jni_YGNodeStyleSetMaxHeightJNI}, + (void*)jni_YGNodeStyleSetMaxHeightJNI}, {"jni_YGNodeStyleSetMaxHeightPercentJNI", "(JF)V", - (void*) jni_YGNodeStyleSetMaxHeightPercentJNI}, + (void*)jni_YGNodeStyleSetMaxHeightPercentJNI}, {"jni_YGNodeStyleGetAspectRatioJNI", "(J)F", - (void*) jni_YGNodeStyleGetAspectRatioJNI}, + (void*)jni_YGNodeStyleGetAspectRatioJNI}, {"jni_YGNodeStyleSetAspectRatioJNI", "(JF)V", - (void*) jni_YGNodeStyleSetAspectRatioJNI}, + (void*)jni_YGNodeStyleSetAspectRatioJNI}, {"jni_YGNodeSetHasMeasureFuncJNI", "(JZ)V", - (void*) jni_YGNodeSetHasMeasureFuncJNI}, - {"jni_YGNodeStyleGetGapJNI", "(JI)F", (void*) jni_YGNodeStyleGetGapJNI}, - {"jni_YGNodeStyleSetGapJNI", "(JIF)V", (void*) jni_YGNodeStyleSetGapJNI}, + (void*)jni_YGNodeSetHasMeasureFuncJNI}, + {"jni_YGNodeStyleGetGapJNI", "(JI)F", (void*)jni_YGNodeStyleGetGapJNI}, + {"jni_YGNodeStyleSetGapJNI", "(JIF)V", (void*)jni_YGNodeStyleSetGapJNI}, {"jni_YGNodeSetHasBaselineFuncJNI", "(JZ)V", - (void*) jni_YGNodeSetHasBaselineFuncJNI}, - {"jni_YGNodePrintJNI", "(J)V", (void*) jni_YGNodePrintJNI}, - {"jni_YGNodeCloneJNI", "(J)J", (void*) jni_YGNodeCloneJNI}, + (void*)jni_YGNodeSetHasBaselineFuncJNI}, + {"jni_YGNodePrintJNI", "(J)V", (void*)jni_YGNodePrintJNI}, + {"jni_YGNodeCloneJNI", "(J)J", (void*)jni_YGNodeCloneJNI}, }; void YGJNIVanilla::registerNatives(JNIEnv* env) { diff --git a/java/jni/YGJTypesVanilla.h b/java/jni/YGJTypesVanilla.h index 705e1eda6f..5d21871c8e 100644 --- a/java/jni/YGJTypesVanilla.h +++ b/java/jni/YGJTypesVanilla.h @@ -19,7 +19,7 @@ class PtrJNodeMapVanilla { std::map ptrsToIdxs_{}; jobjectArray javaNodes_{}; -public: + public: PtrJNodeMapVanilla() = default; PtrJNodeMapVanilla(jlongArray javaNativePointers, jobjectArray javaNodes) @@ -33,7 +33,7 @@ class PtrJNodeMapVanilla { javaNativePointers, 0, nativePointersSize, nativePointers.data()); for (jsize i = 0; i < nativePointersSize; ++i) { - ptrsToIdxs_[(YGNodeConstRef) nativePointers[static_cast(i)]] = i; + ptrsToIdxs_[(YGNodeConstRef)nativePointers[static_cast(i)]] = i; } } diff --git a/java/jni/YogaJniException.cpp b/java/jni/YogaJniException.cpp index aabbc75337..a30b8a6a8a 100644 --- a/java/jni/YogaJniException.cpp +++ b/java/jni/YogaJniException.cpp @@ -5,9 +5,9 @@ * LICENSE file in the root directory of this source tree. */ +#include "YogaJniException.h" #include #include -#include "YogaJniException.h" #include "common.h" namespace facebook::yoga::vanillajni { diff --git a/java/jni/YogaJniException.h b/java/jni/YogaJniException.h index 7c858b5ac8..1d2cc95611 100644 --- a/java/jni/YogaJniException.h +++ b/java/jni/YogaJniException.h @@ -16,7 +16,7 @@ namespace facebook::yoga::vanillajni { * does not gets cleared before jni call completion */ class YogaJniException : public std::exception { -public: + public: YogaJniException(); ~YogaJniException() override; @@ -28,7 +28,7 @@ class YogaJniException : public std::exception { ScopedLocalRef getThrowable() const noexcept; -private: + private: ScopedGlobalRef throwable_; }; diff --git a/java/jni/common.cpp b/java/jni/common.cpp index 317d40465c..e2dc0df22c 100644 --- a/java/jni/common.cpp +++ b/java/jni/common.cpp @@ -76,11 +76,8 @@ DEFINE_CALL_METHOD_FOR_PRIMITIVE_INTERFACE(void, Void) { assertNoPendingJniException(env); } -ScopedLocalRef callStaticObjectMethod( - JNIEnv* env, - jclass clazz, - jmethodID methodId, - ...) { +ScopedLocalRef +callStaticObjectMethod(JNIEnv* env, jclass clazz, jmethodID methodId, ...) { va_list args; va_start(args, methodId); jobject result = env->CallStaticObjectMethodV(clazz, methodId, args); diff --git a/java/jni/common.h b/java/jni/common.h index 57631618cd..eb63554d82 100644 --- a/java/jni/common.h +++ b/java/jni/common.h @@ -59,11 +59,8 @@ DEFINE_CALL_METHOD_FOR_PRIMITIVE_INTERFACE(void, Void); DEFINE_CALL_METHOD_FOR_PRIMITIVE_INTERFACE(jlong, Long); DEFINE_CALL_METHOD_FOR_PRIMITIVE_INTERFACE(jfloat, Float); -ScopedLocalRef callStaticObjectMethod( - JNIEnv* env, - jclass clazz, - jmethodID methodId, - ...); +ScopedLocalRef +callStaticObjectMethod(JNIEnv* env, jclass clazz, jmethodID methodId, ...); /** * Given a local or a global reference, this method creates a new global diff --git a/java/jni/corefunctions.cpp b/java/jni/corefunctions.cpp index bcaf811923..f094357cf2 100644 --- a/java/jni/corefunctions.cpp +++ b/java/jni/corefunctions.cpp @@ -6,8 +6,8 @@ */ #include "corefunctions.h" -#include "macros.h" #include "YogaJniException.h" +#include "macros.h" namespace facebook::yoga::vanillajni { @@ -44,7 +44,7 @@ jint ensureInitialized(JNIEnv** env, JavaVM* vm) { // TODO why we need JNIEXPORT for getCurrentEnv ? JNIEXPORT JNIEnv* getCurrentEnv() { JNIEnv* env; - jint ret = globalVm->GetEnv((void**) &env, JNI_VERSION_1_6); + jint ret = globalVm->GetEnv((void**)&env, JNI_VERSION_1_6); if (ret != JNI_OK) { logErrorMessageAndDie( "There was an error retrieving the current JNIEnv. Make sure the " @@ -54,7 +54,7 @@ JNIEXPORT JNIEnv* getCurrentEnv() { } void logErrorMessageAndDie(const char* message) { - (void) message; + (void)message; VANILLAJNI_LOG_ERROR( "VanillaJni", "Aborting due to error detected in native code: %s", diff --git a/javascript/src/Config.h b/javascript/src/Config.h index 5a15bd450d..cc1441fee1 100644 --- a/javascript/src/Config.h +++ b/javascript/src/Config.h @@ -10,36 +10,35 @@ #include class Config { - friend class Node; -public: + public: static Config* create(void); static void destroy(Config* config); -private: + private: Config(void); -public: + public: ~Config(void); -public: // Prevent accidental copy + public: // Prevent accidental copy Config(Config const&) = delete; Config const& operator=(Config const&) = delete; -public: // Setters + public: // Setters void setExperimentalFeatureEnabled(int feature, bool enabled); void setPointScaleFactor(float pixelsInPoint); void setErrata(int errata); void setUseWebDefaults(bool useWebDefaults); -public: // Getters + public: // Getters bool isExperimentalFeatureEnabled(int feature) const; int getErrata() const; bool useWebDefaults() const; -private: + private: YGConfigRef m_config; }; diff --git a/javascript/src/Node.cpp b/javascript/src/Node.cpp index 7f4d674511..26f80811e5 100644 --- a/javascript/src/Node.cpp +++ b/javascript/src/Node.cpp @@ -9,10 +9,10 @@ #include -#include "./Node.h" +#include "./Config.h" #include "./Layout.h" +#include "./Node.h" #include "./Size.h" -#include "./Config.h" static YGSize globalMeasureFunc( YGNodeConstRef nodeRef, diff --git a/javascript/src/Node.h b/javascript/src/Node.h index 7adb5424c0..643bf7f387 100644 --- a/javascript/src/Node.h +++ b/javascript/src/Node.h @@ -12,23 +12,20 @@ #include #include +#include "./Config.h" #include "./Layout.h" #include "./Size.h" #include "./Value.h" -#include "./Config.h" class MeasureCallback { -public: + public: virtual ~MeasureCallback() {} - virtual Size measure( - float width, - int widthMode, - float height, - int heightMode) = 0; + virtual Size + measure(float width, int widthMode, float height, int heightMode) = 0; }; class MeasureCallbackWrapper : public emscripten::wrapper { -public: + public: EMSCRIPTEN_WRAPPER(MeasureCallbackWrapper); Size measure(float width, int widthMode, float height, int heightMode) { return call("measure", width, widthMode, height, heightMode); @@ -36,43 +33,44 @@ class MeasureCallbackWrapper : public emscripten::wrapper { }; class DirtiedCallback { -public: + public: virtual ~DirtiedCallback() {} virtual void dirtied() = 0; }; class DirtiedCallbackWrapper : public emscripten::wrapper { -public: + public: EMSCRIPTEN_WRAPPER(DirtiedCallbackWrapper); - void dirtied() { return call("dirtied"); } + void dirtied() { + return call("dirtied"); + } }; class Node { - -public: + public: static Node* createDefault(void); static Node* createWithConfig(Config* config); static void destroy(Node* node); -public: + public: static Node* fromYGNode(YGNodeRef nodeRef); -private: + private: Node(Config* config); -public: + public: ~Node(void); -public: // Prevent accidental copy + public: // Prevent accidental copy Node(Node const&) = delete; Node const& operator=(Node const&) = delete; -public: + public: void reset(void); -public: // Style setters + public: // Style setters void copyStyle(Node const& other); void setPositionType(int positionType); @@ -126,7 +124,7 @@ class Node { void setGap(int gutter, double gapLength); -public: // Style getters + public: // Style getters int getPositionType(void) const; Value getPosition(int edge) const; @@ -163,11 +161,11 @@ class Node { float getGap(int gutter); -public: // Tree hierarchy mutators + public: // Tree hierarchy mutators void insertChild(Node* child, unsigned index); void removeChild(Node* child); -public: // Tree hierarchy inspectors + public: // Tree hierarchy inspectors unsigned getChildCount(void) const; // The following functions cannot be const because they could discard const @@ -176,32 +174,32 @@ class Node { Node* getParent(void); Node* getChild(unsigned index); -public: // Measure func mutators + public: // Measure func mutators void setMeasureFunc(MeasureCallback* measureFunc); void unsetMeasureFunc(void); -public: // Measure func inspectors + public: // Measure func inspectors Size callMeasureFunc( double width, int widthMode, double height, int heightMode) const; -public: // Dirtied func mutators + public: // Dirtied func mutators void setDirtiedFunc(DirtiedCallback* dirtiedFunc); void unsetDirtiedFunc(void); -public: // Dirtied func inspectors + public: // Dirtied func inspectors void callDirtiedFunc(void) const; -public: // Dirtiness accessors + public: // Dirtiness accessors void markDirty(void); bool isDirty(void) const; -public: // Layout mutators + public: // Layout mutators void calculateLayout(double width, double height, int direction); -public: // Layout inspectors + public: // Layout inspectors double getComputedLeft(void) const; double getComputedRight(void) const; @@ -217,7 +215,7 @@ class Node { double getComputedBorder(int edge) const; double getComputedPadding(int edge) const; -public: + public: void setIsReferenceBaseline(bool isReferenceBaseline); bool isReferenceBaseline(); diff --git a/javascript/src/embind.cpp b/javascript/src/embind.cpp index e9b79c8f76..5538d8dd97 100644 --- a/javascript/src/embind.cpp +++ b/javascript/src/embind.cpp @@ -5,14 +5,14 @@ * LICENSE file in the root directory of this source tree. */ -#include "./Node.h" +#include "./Config.h" #include "./Layout.h" +#include "./Node.h" #include "./Size.h" #include "./Value.h" -#include "./Config.h" -#include #include +#include using namespace emscripten; diff --git a/tests/CompactValueTest.cpp b/tests/CompactValueTest.cpp index 5b78a06074..76281c51b4 100644 --- a/tests/CompactValueTest.cpp +++ b/tests/CompactValueTest.cpp @@ -7,8 +7,8 @@ #define YOGA_COMPACT_VALUE_TEST -#include #include +#include #include using facebook::yoga::CompactValue; @@ -326,10 +326,10 @@ TEST(YogaTest, can_be_assigned_from_YGValue) { YGValue v{2.0f, YGUnitPercent}; c = v; - ASSERT_EQ((YGValue) c, v); + ASSERT_EQ((YGValue)c, v); c = YGValue{123, YGUnitPoint}; - ASSERT_EQ((YGValue) c, (YGValue{123, YGUnitPoint})); + ASSERT_EQ((YGValue)c, (YGValue{123, YGUnitPoint})); } TEST(YogaTest, compact_value_bound_representations) { diff --git a/tests/EventsTest.cpp b/tests/EventsTest.cpp index 7aa8015df7..0612f8f82f 100644 --- a/tests/EventsTest.cpp +++ b/tests/EventsTest.cpp @@ -6,9 +6,9 @@ */ #include -#include -#include #include +#include +#include #include #include @@ -48,9 +48,11 @@ class EventTest : public ::testing::Test { ScopedEventSubscription subscription = {&EventTest::listen}; static void listen(YGNodeConstRef, Event::Type, Event::Data); -public: + public: static std::vector events; - static EventArgs& lastEvent() { return events.back(); } + static EventArgs& lastEvent() { + return events.back(); + } void TearDown() override; }; diff --git a/tests/FloatOptionalTest.cpp b/tests/FloatOptionalTest.cpp index 95a3f3da94..9163a0a1eb 100644 --- a/tests/FloatOptionalTest.cpp +++ b/tests/FloatOptionalTest.cpp @@ -7,9 +7,9 @@ #include +#include #include #include -#include using namespace facebook; using namespace facebook::yoga; diff --git a/tests/NumericBitfieldTest.cpp b/tests/NumericBitfieldTest.cpp index 7b4e2abe86..74f101c29b 100644 --- a/tests/NumericBitfieldTest.cpp +++ b/tests/NumericBitfieldTest.cpp @@ -7,8 +7,8 @@ #include -#include #include +#include namespace facebook::yoga { @@ -105,7 +105,7 @@ TEST(NumericBitfield, third_boolean_can_be_set_to_true) { TEST(NumericBitfield, setting_boolean_values_does_not_spill_over) { uint32_t flags = 0; - setBooleanData(flags, 1, (bool) 7); + setBooleanData(flags, 1, (bool)7); ASSERT_EQ(getBooleanData(flags, 0), false); ASSERT_EQ(getBooleanData(flags, 1), true); @@ -195,7 +195,7 @@ TEST(NumericBitfield, setting_values_does_not_spill_over) { static constexpr size_t boolOffset = 7; uint32_t edge = 0xffffff; - setEnumData(flags, edgesOffset, (YGEdge) edge); + setEnumData(flags, edgesOffset, (YGEdge)edge); ASSERT_EQ(getEnumData(flags, alignOffset), 0); ASSERT_EQ(getBooleanData(flags, boolOffset), false); diff --git a/tests/YGAlignBaselineTest.cpp b/tests/YGAlignBaselineTest.cpp index 2750a474b6..f4d60151b4 100644 --- a/tests/YGAlignBaselineTest.cpp +++ b/tests/YGAlignBaselineTest.cpp @@ -44,8 +44,8 @@ static YGNodeRef createYGNode( if (alignBaseline) { YGNodeStyleSetAlignItems(node, YGAlignBaseline); } - YGNodeStyleSetWidth(node, (float) width); - YGNodeStyleSetHeight(node, (float) height); + YGNodeStyleSetWidth(node, (float)width); + YGNodeStyleSetHeight(node, (float)height); return node; } diff --git a/tests/YGBaselineFuncTest.cpp b/tests/YGBaselineFuncTest.cpp index d93910d489..a2ea241590 100644 --- a/tests/YGBaselineFuncTest.cpp +++ b/tests/YGBaselineFuncTest.cpp @@ -8,11 +8,9 @@ #include #include -static float _baseline( - YGNodeConstRef node, - const float /*width*/, - const float /*height*/) { - float* baseline = (float*) YGNodeGetContext(node); +static float +_baseline(YGNodeConstRef node, const float /*width*/, const float /*height*/) { + float* baseline = (float*)YGNodeGetContext(node); return *baseline; } diff --git a/tests/YGDirtiedTest.cpp b/tests/YGDirtiedTest.cpp index 6b9b38f685..67e6b40321 100644 --- a/tests/YGDirtiedTest.cpp +++ b/tests/YGDirtiedTest.cpp @@ -12,7 +12,7 @@ using namespace facebook; static void _dirtied(YGNodeConstRef node) { - int* dirtiedCount = (int*) YGNodeGetContext(node); + int* dirtiedCount = (int*)YGNodeGetContext(node); (*dirtiedCount)++; } diff --git a/tests/YGHadOverflowTest.cpp b/tests/YGHadOverflowTest.cpp index 4c047a6603..5537a4b8da 100644 --- a/tests/YGHadOverflowTest.cpp +++ b/tests/YGHadOverflowTest.cpp @@ -11,7 +11,7 @@ using namespace ::testing; class YogaTest_HadOverflowTests : public Test { -protected: + protected: YogaTest_HadOverflowTests() { config = YGConfigNew(); root = YGNodeNewWithConfig(config); diff --git a/tests/YGLoggerTest.cpp b/tests/YGLoggerTest.cpp index 276d3fe0ca..acc66152c6 100644 --- a/tests/YGLoggerTest.cpp +++ b/tests/YGLoggerTest.cpp @@ -75,7 +75,7 @@ TEST(YogaTest, logger_default_node_should_print_no_style_info) { YGNodeCalculateLayout(root, YGUnitUndefined, YGUnitUndefined, YGDirectionLTR); YGNodePrint( root, - (YGPrintOptions) (YGPrintOptionsLayout | YGPrintOptionsChildren | YGPrintOptionsStyle)); + (YGPrintOptions)(YGPrintOptionsLayout | YGPrintOptionsChildren | YGPrintOptionsStyle)); YGConfigSetLogger(config, NULL); YGNodeFree(root); @@ -99,7 +99,7 @@ TEST(YogaTest, logger_node_with_percentage_absolute_position_and_margin) { YGNodeCalculateLayout(root, YGUnitUndefined, YGUnitUndefined, YGDirectionLTR); YGNodePrint( root, - (YGPrintOptions) (YGPrintOptionsLayout | YGPrintOptionsChildren | YGPrintOptionsStyle)); + (YGPrintOptions)(YGPrintOptionsLayout | YGPrintOptionsChildren | YGPrintOptionsStyle)); YGConfigSetLogger(config, NULL); YGNodeFree(root); @@ -122,7 +122,7 @@ TEST(YogaTest, logger_node_with_children_should_print_indented) { YGNodeCalculateLayout(root, YGUnitUndefined, YGUnitUndefined, YGDirectionLTR); YGNodePrint( root, - (YGPrintOptions) (YGPrintOptionsLayout | YGPrintOptionsChildren | YGPrintOptionsStyle)); + (YGPrintOptions)(YGPrintOptionsLayout | YGPrintOptionsChildren | YGPrintOptionsStyle)); YGConfigSetLogger(config, NULL); YGNodeFreeRecursive(root); diff --git a/tests/YGMeasureCacheTest.cpp b/tests/YGMeasureCacheTest.cpp index f5d73520eb..98a0f5684e 100644 --- a/tests/YGMeasureCacheTest.cpp +++ b/tests/YGMeasureCacheTest.cpp @@ -14,7 +14,7 @@ static YGSize _measureMax( YGMeasureMode widthMode, float height, YGMeasureMode heightMode) { - int* measureCount = (int*) YGNodeGetContext(node); + int* measureCount = (int*)YGNodeGetContext(node); (*measureCount)++; return YGSize{ @@ -29,7 +29,7 @@ static YGSize _measureMin( YGMeasureMode widthMode, float height, YGMeasureMode heightMode) { - int* measureCount = (int*) YGNodeGetContext(node); + int* measureCount = (int*)YGNodeGetContext(node); *measureCount = *measureCount + 1; return YGSize{ widthMode == YGMeasureModeUndefined || @@ -49,7 +49,7 @@ static YGSize _measure_84_49( YGMeasureMode /*widthMode*/, float /*height*/, YGMeasureMode /*heightMode*/) { - int* measureCount = (int*) YGNodeGetContext(node); + int* measureCount = (int*)YGNodeGetContext(node); if (measureCount) { (*measureCount)++; } diff --git a/tests/YGMeasureModeTest.cpp b/tests/YGMeasureModeTest.cpp index 8825a02374..b4d7f4fb7c 100644 --- a/tests/YGMeasureModeTest.cpp +++ b/tests/YGMeasureModeTest.cpp @@ -27,7 +27,7 @@ static YGSize _measure( float height, YGMeasureMode heightMode) { struct _MeasureConstraintList* constraintList = - (struct _MeasureConstraintList*) YGNodeGetContext(node); + (struct _MeasureConstraintList*)YGNodeGetContext(node); struct _MeasureConstraint* constraints = constraintList->constraints; uint32_t currentIndex = constraintList->length; (&constraints[currentIndex])->width = width; @@ -45,7 +45,7 @@ static YGSize _measure( TEST(YogaTest, exactly_measure_stretched_child_column) { struct _MeasureConstraintList constraintList = _MeasureConstraintList{ 0, - (struct _MeasureConstraint*) malloc( + (struct _MeasureConstraint*)malloc( 10 * sizeof(struct _MeasureConstraint)), }; @@ -72,7 +72,7 @@ TEST(YogaTest, exactly_measure_stretched_child_column) { TEST(YogaTest, exactly_measure_stretched_child_row) { struct _MeasureConstraintList constraintList = _MeasureConstraintList{ 0, - (struct _MeasureConstraint*) malloc( + (struct _MeasureConstraint*)malloc( 10 * sizeof(struct _MeasureConstraint)), }; @@ -100,7 +100,7 @@ TEST(YogaTest, exactly_measure_stretched_child_row) { TEST(YogaTest, at_most_main_axis_column) { struct _MeasureConstraintList constraintList = _MeasureConstraintList{ 0, - (struct _MeasureConstraint*) malloc( + (struct _MeasureConstraint*)malloc( 10 * sizeof(struct _MeasureConstraint)), }; @@ -127,7 +127,7 @@ TEST(YogaTest, at_most_main_axis_column) { TEST(YogaTest, at_most_cross_axis_column) { struct _MeasureConstraintList constraintList = _MeasureConstraintList{ 0, - (struct _MeasureConstraint*) malloc( + (struct _MeasureConstraint*)malloc( 10 * sizeof(struct _MeasureConstraint)), }; @@ -155,7 +155,7 @@ TEST(YogaTest, at_most_cross_axis_column) { TEST(YogaTest, at_most_main_axis_row) { struct _MeasureConstraintList constraintList = _MeasureConstraintList{ 0, - (struct _MeasureConstraint*) malloc( + (struct _MeasureConstraint*)malloc( 10 * sizeof(struct _MeasureConstraint)), }; @@ -183,7 +183,7 @@ TEST(YogaTest, at_most_main_axis_row) { TEST(YogaTest, at_most_cross_axis_row) { struct _MeasureConstraintList constraintList = _MeasureConstraintList{ 0, - (struct _MeasureConstraint*) malloc( + (struct _MeasureConstraint*)malloc( 10 * sizeof(struct _MeasureConstraint)), }; @@ -212,7 +212,7 @@ TEST(YogaTest, at_most_cross_axis_row) { TEST(YogaTest, flex_child) { struct _MeasureConstraintList constraintList = _MeasureConstraintList{ 0, - (struct _MeasureConstraint*) malloc( + (struct _MeasureConstraint*)malloc( 10 * sizeof(struct _MeasureConstraint)), }; @@ -242,7 +242,7 @@ TEST(YogaTest, flex_child) { TEST(YogaTest, flex_child_with_flex_basis) { struct _MeasureConstraintList constraintList = _MeasureConstraintList{ 0, - (struct _MeasureConstraint*) malloc( + (struct _MeasureConstraint*)malloc( 10 * sizeof(struct _MeasureConstraint)), }; @@ -270,7 +270,7 @@ TEST(YogaTest, flex_child_with_flex_basis) { TEST(YogaTest, overflow_scroll_column) { struct _MeasureConstraintList constraintList = _MeasureConstraintList{ 0, - (struct _MeasureConstraint*) malloc( + (struct _MeasureConstraint*)malloc( 10 * sizeof(struct _MeasureConstraint)), }; @@ -302,7 +302,7 @@ TEST(YogaTest, overflow_scroll_column) { TEST(YogaTest, overflow_scroll_row) { struct _MeasureConstraintList constraintList = _MeasureConstraintList{ 0, - (struct _MeasureConstraint*) malloc( + (struct _MeasureConstraint*)malloc( 10 * sizeof(struct _MeasureConstraint)), }; diff --git a/tests/YGMeasureTest.cpp b/tests/YGMeasureTest.cpp index cce30f8d2a..de9e757da9 100644 --- a/tests/YGMeasureTest.cpp +++ b/tests/YGMeasureTest.cpp @@ -14,7 +14,7 @@ static YGSize _measure( YGMeasureMode /*widthMode*/, float /*height*/, YGMeasureMode /*heightMode*/) { - int* measureCount = (int*) YGNodeGetContext(node); + int* measureCount = (int*)YGNodeGetContext(node); if (measureCount) { (*measureCount)++; } @@ -645,7 +645,6 @@ static YGSize _measure_90_10( YGMeasureMode /*widthMode*/, float /*height*/, YGMeasureMode /*heightMode*/) { - return YGSize{90, 10}; } @@ -655,7 +654,6 @@ static YGSize _measure_100_100( YGMeasureMode /*widthMode*/, float /*height*/, YGMeasureMode /*heightMode*/) { - return YGSize{100, 100}; } diff --git a/tests/YGRoundingFunctionTest.cpp b/tests/YGRoundingFunctionTest.cpp index f7fa7a8a77..7fb2d30bdb 100644 --- a/tests/YGRoundingFunctionTest.cpp +++ b/tests/YGRoundingFunctionTest.cpp @@ -6,8 +6,8 @@ */ #include -#include #include +#include TEST(YogaTest, rounding_value) { // Test that whole numbers are rounded to whole despite ceil/floor flags @@ -70,7 +70,7 @@ TEST(YogaTest, consistent_rounding_during_repeated_layouts) { for (int i = 0; i < 5; i++) { // Dirty the tree so YGRoundToPixelGrid runs again - YGNodeStyleSetMargin(root, YGEdgeLeft, (float) (i + 1)); + YGNodeStyleSetMargin(root, YGEdgeLeft, (float)(i + 1)); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(node1)); diff --git a/tests/YGStyleAccessorsTest.cpp b/tests/YGStyleAccessorsTest.cpp index 390743e38b..d32ffc5d2f 100644 --- a/tests/YGStyleAccessorsTest.cpp +++ b/tests/YGStyleAccessorsTest.cpp @@ -5,11 +5,11 @@ * LICENSE file in the root directory of this source tree. */ -#include -#include #include #include #include +#include +#include #define ACCESSOR_TESTS_1(NAME, X) \ style.NAME() = X; \ diff --git a/tests/util/TestUtil.cpp b/tests/util/TestUtil.cpp index 16e3fd6a58..2556f89c09 100644 --- a/tests/util/TestUtil.cpp +++ b/tests/util/TestUtil.cpp @@ -7,8 +7,8 @@ #include "TestUtil.h" -#include #include +#include namespace facebook::yoga::test { @@ -20,7 +20,6 @@ void yogaEventSubscriber( YGNodeConstRef /*node*/, Event::Type eventType, const Event::Data& /*eventData*/) { - switch (eventType) { case Event::NodeAllocation: nodeInstanceCount++; diff --git a/yoga/Yoga.cpp b/yoga/Yoga.cpp index c8eff1ece3..34ef7f9f30 100644 --- a/yoga/Yoga.cpp +++ b/yoga/Yoga.cpp @@ -5,8 +5,8 @@ * LICENSE file in the root directory of this source tree. */ -#include #include +#include #include #include diff --git a/yoga/Yoga.h b/yoga/Yoga.h index b1ebf8856c..cafbadb66e 100644 --- a/yoga/Yoga.h +++ b/yoga/Yoga.h @@ -71,10 +71,8 @@ YG_EXPORT YGNodeRef YGNodeGetChild(YGNodeRef node, size_t index); YG_EXPORT YGNodeRef YGNodeGetOwner(YGNodeRef node); YG_EXPORT YGNodeRef YGNodeGetParent(YGNodeRef node); YG_EXPORT size_t YGNodeGetChildCount(YGNodeConstRef node); -YG_EXPORT void YGNodeSetChildren( - YGNodeRef owner, - const YGNodeRef* children, - size_t count); +YG_EXPORT void +YGNodeSetChildren(YGNodeRef owner, const YGNodeRef* children, size_t count); YG_EXPORT void YGNodeSetIsReferenceBaseline( YGNodeRef node, @@ -197,41 +195,29 @@ YG_EXPORT void YGNodeStyleSetFlexBasisPercent(YGNodeRef node, float flexBasis); YG_EXPORT void YGNodeStyleSetFlexBasisAuto(YGNodeRef node); YG_EXPORT YGValue YGNodeStyleGetFlexBasis(YGNodeConstRef node); -YG_EXPORT void YGNodeStyleSetPosition( - YGNodeRef node, - YGEdge edge, - float position); -YG_EXPORT void YGNodeStyleSetPositionPercent( - YGNodeRef node, - YGEdge edge, - float position); +YG_EXPORT void +YGNodeStyleSetPosition(YGNodeRef node, YGEdge edge, float position); +YG_EXPORT void +YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge, float position); YG_EXPORT YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge); YG_EXPORT void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float margin); -YG_EXPORT void YGNodeStyleSetMarginPercent( - YGNodeRef node, - YGEdge edge, - float margin); +YG_EXPORT void +YGNodeStyleSetMarginPercent(YGNodeRef node, YGEdge edge, float margin); YG_EXPORT void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge); YG_EXPORT YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge); -YG_EXPORT void YGNodeStyleSetPadding( - YGNodeRef node, - YGEdge edge, - float padding); -YG_EXPORT void YGNodeStyleSetPaddingPercent( - YGNodeRef node, - YGEdge edge, - float padding); +YG_EXPORT void +YGNodeStyleSetPadding(YGNodeRef node, YGEdge edge, float padding); +YG_EXPORT void +YGNodeStyleSetPaddingPercent(YGNodeRef node, YGEdge edge, float padding); YG_EXPORT YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge); YG_EXPORT void YGNodeStyleSetBorder(YGNodeRef node, YGEdge edge, float border); YG_EXPORT float YGNodeStyleGetBorder(YGNodeConstRef node, YGEdge edge); -YG_EXPORT void YGNodeStyleSetGap( - YGNodeRef node, - YGGutter gutter, - float gapLength); +YG_EXPORT void +YGNodeStyleSetGap(YGNodeRef node, YGGutter gutter, float gapLength); YG_EXPORT float YGNodeStyleGetGap(YGNodeConstRef node, YGGutter gutter); YG_EXPORT void YGNodeStyleSetWidth(YGNodeRef node, float width); diff --git a/yoga/algorithm/Baseline.cpp b/yoga/algorithm/Baseline.cpp index a3fd42c577..4ea00843b9 100644 --- a/yoga/algorithm/Baseline.cpp +++ b/yoga/algorithm/Baseline.cpp @@ -16,7 +16,6 @@ namespace facebook::yoga { float calculateBaseline(const yoga::Node* node) { if (node->hasBaselineFunc()) { - Event::publish(node); const float baseline = node->baseline( diff --git a/yoga/algorithm/CalculateLayout.cpp b/yoga/algorithm/CalculateLayout.cpp index d884962b16..4288363721 100644 --- a/yoga/algorithm/CalculateLayout.cpp +++ b/yoga/algorithm/CalculateLayout.cpp @@ -2603,7 +2603,6 @@ bool calculateLayoutInternal( layout->lastOwnerDirection = ownerDirection; if (cachedResults == nullptr) { - layoutMarkerData.maxMeasureCache = std::max( layoutMarkerData.maxMeasureCache, layout->nextCachedMeasurementsIndex + 1u); @@ -2741,7 +2740,7 @@ void calculateLayout( if (node->getConfig()->shouldPrintTree()) { YGNodePrint( node, - (YGPrintOptions) (YGPrintOptionsLayout | YGPrintOptionsChildren | YGPrintOptionsStyle)); + (YGPrintOptions)(YGPrintOptionsLayout | YGPrintOptionsChildren | YGPrintOptionsStyle)); } #endif } diff --git a/yoga/algorithm/PixelGrid.cpp b/yoga/algorithm/PixelGrid.cpp index b2749e9fbb..a9594b24d1 100644 --- a/yoga/algorithm/PixelGrid.cpp +++ b/yoga/algorithm/PixelGrid.cpp @@ -59,7 +59,7 @@ float roundValueToPixelGrid( } return (std::isnan(scaledValue) || std::isnan(pointScaleFactor)) ? YGUndefined - : (float) (scaledValue / pointScaleFactor); + : (float)(scaledValue / pointScaleFactor); } void roundLayoutResultsToPixelGrid( diff --git a/yoga/algorithm/ResolveValue.h b/yoga/algorithm/ResolveValue.h index af04025d4c..4e03d0c50d 100644 --- a/yoga/algorithm/ResolveValue.h +++ b/yoga/algorithm/ResolveValue.h @@ -26,7 +26,7 @@ inline FloatOptional resolveValue(const YGValue value, const float ownerSize) { } inline FloatOptional resolveValue(CompactValue value, float ownerSize) { - return resolveValue((YGValue) value, ownerSize); + return resolveValue((YGValue)value, ownerSize); } } // namespace facebook::yoga diff --git a/yoga/bits/EnumBitset.h b/yoga/bits/EnumBitset.h index 3dff663f8f..79ee1e7446 100644 --- a/yoga/bits/EnumBitset.h +++ b/yoga/bits/EnumBitset.h @@ -7,8 +7,8 @@ #pragma once -#include #include +#include namespace facebook::yoga { diff --git a/yoga/bits/NumericBitfield.h b/yoga/bits/NumericBitfield.h index 358c4ab7d5..9197a9b9f0 100644 --- a/yoga/bits/NumericBitfield.h +++ b/yoga/bits/NumericBitfield.h @@ -8,8 +8,8 @@ #pragma once #include -#include #include +#include #include diff --git a/yoga/config/Config.h b/yoga/config/Config.h index 67a0299f71..4590fcdf2f 100644 --- a/yoga/config/Config.h +++ b/yoga/config/Config.h @@ -34,7 +34,7 @@ struct ConfigFlags { #pragma pack(pop) class YG_EXPORT Config : public ::YGConfig { -public: + public: Config(YGLogger logger); void setUseWebDefaults(bool useWebDefaults); @@ -69,14 +69,12 @@ class YG_EXPORT Config : public ::YGConfig { va_list args) const; void setCloneNodeCallback(YGCloneNodeFunc cloneNode); - YGNodeRef cloneNode( - YGNodeConstRef node, - YGNodeConstRef owner, - size_t childIndex) const; + YGNodeRef + cloneNode(YGNodeConstRef node, YGNodeConstRef owner, size_t childIndex) const; static const Config& getDefault(); -private: + private: YGCloneNodeFunc cloneNodeCallback_; YGLogger logger_; diff --git a/yoga/debug/AssertFatal.h b/yoga/debug/AssertFatal.h index 5aa3b9e473..929ff1792d 100644 --- a/yoga/debug/AssertFatal.h +++ b/yoga/debug/AssertFatal.h @@ -8,8 +8,8 @@ #pragma once #include -#include #include +#include namespace facebook::yoga { diff --git a/yoga/debug/Log.h b/yoga/debug/Log.h index a595eba824..59a8b2e0db 100644 --- a/yoga/debug/Log.h +++ b/yoga/debug/Log.h @@ -10,8 +10,8 @@ #include #include -#include #include +#include namespace facebook::yoga { diff --git a/yoga/event/event.h b/yoga/event/event.h index 2969f26d02..4e96e049ea 100644 --- a/yoga/event/event.h +++ b/yoga/event/event.h @@ -9,10 +9,10 @@ #include +#include +#include #include #include -#include -#include namespace facebook::yoga { @@ -70,7 +70,7 @@ struct YG_EXPORT Event { class Data { const void* data_; - public: + public: template Data(const TypedData& data) : data_{&data} {} @@ -89,7 +89,7 @@ struct YG_EXPORT Event { publish(node, E, Data{eventData}); } -private: + private: static void publish(YGNodeConstRef, Type, const Data&); }; diff --git a/yoga/node/LayoutResults.h b/yoga/node/LayoutResults.h index 2e1fb38ff1..c533f60dc3 100644 --- a/yoga/node/LayoutResults.h +++ b/yoga/node/LayoutResults.h @@ -10,8 +10,8 @@ #include #include -#include #include +#include namespace facebook::yoga { @@ -34,10 +34,10 @@ struct LayoutResults { std::array border = {}; std::array padding = {}; -private: + private: LayoutResultFlags flags_{}; -public: + public: uint32_t computedFlexBasisGeneration = 0; FloatOptional computedFlexBasis = {}; @@ -60,11 +60,17 @@ struct LayoutResults { flags_.direction = static_cast(direction) & 0x03; } - bool hadOverflow() const { return flags_.hadOverflow; } - void setHadOverflow(bool hadOverflow) { flags_.hadOverflow = hadOverflow; } + bool hadOverflow() const { + return flags_.hadOverflow; + } + void setHadOverflow(bool hadOverflow) { + flags_.hadOverflow = hadOverflow; + } bool operator==(LayoutResults layout) const; - bool operator!=(LayoutResults layout) const { return !(*this == layout); } + bool operator!=(LayoutResults layout) const { + return !(*this == layout); + } }; } // namespace facebook::yoga diff --git a/yoga/node/Node.h b/yoga/node/Node.h index 37f18a5a70..17df371c00 100644 --- a/yoga/node/Node.h +++ b/yoga/node/Node.h @@ -7,8 +7,8 @@ #pragma once -#include #include +#include #include #include @@ -34,7 +34,7 @@ struct NodeFlags { #pragma pack(pop) class YG_EXPORT Node : public ::YGNode { -private: + private: void* context_ = nullptr; NodeFlags flags_ = {}; YGMeasureFunc measureFunc_ = {nullptr}; @@ -66,7 +66,7 @@ class YG_EXPORT Node : public ::YGNode { // DO NOT CHANGE THE VISIBILITY OF THIS METHOD! Node& operator=(Node&&) = default; -public: + public: Node(); explicit Node(const Config* config); ~Node() = default; // cleanup of owner/children relationships in YGNodeFree @@ -82,60 +82,98 @@ class YG_EXPORT Node : public ::YGNode { Node& operator=(const Node&) = delete; // Getters - void* getContext() const { return context_; } + void* getContext() const { + return context_; + } void print(); - bool getHasNewLayout() const { return flags_.hasNewLayout; } + bool getHasNewLayout() const { + return flags_.hasNewLayout; + } YGNodeType getNodeType() const { return static_cast(flags_.nodeType); } - bool hasMeasureFunc() const noexcept { return measureFunc_ != nullptr; } + bool hasMeasureFunc() const noexcept { + return measureFunc_ != nullptr; + } YGSize measure(float, YGMeasureMode, float, YGMeasureMode); - bool hasBaselineFunc() const noexcept { return baselineFunc_ != nullptr; } + bool hasBaselineFunc() const noexcept { + return baselineFunc_ != nullptr; + } float baseline(float width, float height) const; - bool hasErrata(YGErrata errata) const { return config_->hasErrata(errata); } + bool hasErrata(YGErrata errata) const { + return config_->hasErrata(errata); + } - YGDirtiedFunc getDirtiedFunc() const { return dirtiedFunc_; } + YGDirtiedFunc getDirtiedFunc() const { + return dirtiedFunc_; + } // For Performance reasons passing as reference. - Style& getStyle() { return style_; } + Style& getStyle() { + return style_; + } - const Style& getStyle() const { return style_; } + const Style& getStyle() const { + return style_; + } // For Performance reasons passing as reference. - LayoutResults& getLayout() { return layout_; } + LayoutResults& getLayout() { + return layout_; + } - const LayoutResults& getLayout() const { return layout_; } + const LayoutResults& getLayout() const { + return layout_; + } - size_t getLineIndex() const { return lineIndex_; } + size_t getLineIndex() const { + return lineIndex_; + } - bool isReferenceBaseline() const { return flags_.isReferenceBaseline; } + bool isReferenceBaseline() const { + return flags_.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_; } + Node* getOwner() const { + return owner_; + } // Deprecated, use getOwner() instead. - Node* getParent() const { return getOwner(); } + Node* getParent() const { + return getOwner(); + } - const std::vector& getChildren() const { return children_; } + const std::vector& getChildren() const { + return children_; + } - Node* getChild(size_t index) const { return children_.at(index); } + Node* getChild(size_t index) const { + return children_.at(index); + } - size_t getChildCount() const { return children_.size(); } + size_t getChildCount() const { + return children_.size(); + } - const Config* getConfig() const { return config_; } + const Config* getConfig() const { + return config_; + } - bool isDirty() const { return flags_.isDirty; } + bool isDirty() const { + return flags_.isDirty; + } std::array getResolvedDimensions() const { return resolvedDimensions_; @@ -200,9 +238,13 @@ class YG_EXPORT Node : public ::YGNode { const; // Setters - void setContext(void* context) { context_ = context; } + void setContext(void* context) { + context_ = context; + } - void setPrintFunc(YGPrintFunc printFunc) { printFunc_ = printFunc; } + void setPrintFunc(YGPrintFunc printFunc) { + printFunc_ = printFunc; + } void setHasNewLayout(bool hasNewLayout) { flags_.hasNewLayout = hasNewLayout; @@ -218,21 +260,33 @@ class YG_EXPORT Node : public ::YGNode { baselineFunc_ = baseLineFunc; } - void setDirtiedFunc(YGDirtiedFunc dirtiedFunc) { dirtiedFunc_ = dirtiedFunc; } + void setDirtiedFunc(YGDirtiedFunc dirtiedFunc) { + dirtiedFunc_ = dirtiedFunc; + } - void setStyle(const Style& style) { style_ = style; } + void setStyle(const Style& style) { + style_ = style; + } - void setLayout(const LayoutResults& layout) { layout_ = layout; } + void setLayout(const LayoutResults& layout) { + layout_ = layout; + } - void setLineIndex(size_t lineIndex) { lineIndex_ = lineIndex; } + void setLineIndex(size_t lineIndex) { + lineIndex_ = lineIndex; + } void setIsReferenceBaseline(bool isReferenceBaseline) { flags_.isReferenceBaseline = isReferenceBaseline; } - void setOwner(Node* owner) { owner_ = owner; } + void setOwner(Node* owner) { + owner_ = owner; + } - void setChildren(const std::vector& children) { children_ = children; } + void setChildren(const std::vector& children) { + children_ = children; + } // TODO: rvalue override for setChildren diff --git a/yoga/numeric/Comparison.h b/yoga/numeric/Comparison.h index aa9f933efd..0b0c3f7289 100644 --- a/yoga/numeric/Comparison.h +++ b/yoga/numeric/Comparison.h @@ -75,7 +75,7 @@ inline bool inexactEquals(const YGValue& a, const YGValue& b) { } inline bool inexactEquals(CompactValue a, CompactValue b) { - return inexactEquals((YGValue) a, (YGValue) b); + return inexactEquals((YGValue)a, (YGValue)b); } template diff --git a/yoga/numeric/FloatOptional.h b/yoga/numeric/FloatOptional.h index a36befe609..1f61b84211 100644 --- a/yoga/numeric/FloatOptional.h +++ b/yoga/numeric/FloatOptional.h @@ -13,17 +13,21 @@ namespace facebook::yoga { struct FloatOptional { -private: + private: float value_ = std::numeric_limits::quiet_NaN(); -public: + 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 unwrap() const { + return value_; + } - bool isUndefined() const { return std::isnan(value_); } + bool isUndefined() const { + return std::isnan(value_); + } }; // operators take FloatOptional by value, as it is a 32bit value diff --git a/yoga/style/CompactValue.h b/yoga/style/CompactValue.h index 596331ad86..8fa0892cf4 100644 --- a/yoga/style/CompactValue.h +++ b/yoga/style/CompactValue.h @@ -44,7 +44,7 @@ namespace facebook::yoga { class YG_EXPORT CompactValue { friend constexpr bool operator==(CompactValue, CompactValue) noexcept; -public: + public: static constexpr auto LOWER_BOUND = 1.08420217e-19f; static constexpr auto UPPER_BOUND_POINT = 36893485948395847680.0f; static constexpr auto UPPER_BOUND_PERCENT = 18446742974197923840.0f; @@ -136,9 +136,11 @@ class YG_EXPORT CompactValue { repr_ != ZERO_BITS_PERCENT && std::isnan(yoga::bit_cast(repr_))); } - bool isAuto() const noexcept { return repr_ == AUTO_BITS; } + bool isAuto() const noexcept { + return repr_ == AUTO_BITS; + } -private: + private: uint32_t repr_; static constexpr uint32_t BIAS = 0x20000000; @@ -152,7 +154,9 @@ class YG_EXPORT CompactValue { constexpr CompactValue(uint32_t data) noexcept : repr_(data) {} - VISIBLE_FOR_TESTING uint32_t repr() { return repr_; } + VISIBLE_FOR_TESTING uint32_t repr() { + return repr_; + } }; template <> diff --git a/yoga/style/Style.cpp b/yoga/style/Style.cpp index fc26834702..070de8b6ea 100644 --- a/yoga/style/Style.cpp +++ b/yoga/style/Style.cpp @@ -5,8 +5,8 @@ * LICENSE file in the root directory of this source tree. */ -#include #include +#include namespace facebook::yoga { diff --git a/yoga/style/Style.h b/yoga/style/Style.h index 14efebd216..a8191aa70c 100644 --- a/yoga/style/Style.h +++ b/yoga/style/Style.h @@ -24,7 +24,7 @@ class YG_EXPORT Style { template using Values = std::array()>; -public: + public: using Dimensions = Values; using Edges = Values; using Gutters = Values; @@ -37,7 +37,9 @@ class YG_EXPORT Style { struct BitfieldRef { Style& style; uint8_t offset; - operator T() const { return getEnumData(style.flags, offset); } + operator T() const { + return getEnumData(style.flags, offset); + } BitfieldRef& operator=(T x) { setEnumData(style.flags, offset, x); return *this; @@ -47,7 +49,9 @@ class YG_EXPORT Style { template struct Ref { Style& style; - operator T() const { return style.*Prop; } + operator T() const { + return style.*Prop; + } Ref& operator=(T value) { style.*Prop = value; return *this; @@ -59,8 +63,12 @@ class YG_EXPORT Style { struct Ref { Style& style; Idx idx; - operator CompactValue() const { return (style.*Prop)[idx]; } - operator YGValue() const { return (style.*Prop)[idx]; } + operator CompactValue() const { + return (style.*Prop)[idx]; + } + operator YGValue() const { + return (style.*Prop)[idx]; + } Ref& operator=(CompactValue value) { (style.*Prop)[idx] = value; return *this; @@ -72,9 +80,15 @@ class YG_EXPORT Style { style.*Prop = values; return *this; } - operator const Values&() const { return style.*Prop; } - Ref operator[](Idx idx) { return {style, idx}; } - CompactValue operator[](Idx idx) const { return (style.*Prop)[idx]; } + operator const Values&() const { + return style.*Prop; + } + Ref operator[](Idx idx) { + return {style, idx}; + } + CompactValue operator[](Idx idx) const { + return (style.*Prop)[idx]; + } }; Style() { @@ -83,7 +97,7 @@ class YG_EXPORT Style { } ~Style() = default; -private: + private: static constexpr uint8_t directionOffset = 0; static constexpr uint8_t flexdirectionOffset = directionOffset + minimumBitCount(); @@ -121,14 +135,16 @@ class YG_EXPORT Style { // Yoga specific properties, not compatible with flexbox specification FloatOptional aspectRatio_ = {}; -public: + public: // for library users needing a type using ValueRepr = std::remove_reference::type; YGDirection direction() const { return getEnumData(flags, directionOffset); } - BitfieldRef direction() { return {*this, directionOffset}; } + BitfieldRef direction() { + return {*this, directionOffset}; + } YGFlexDirection flexDirection() const { return getEnumData(flags, flexdirectionOffset); @@ -147,17 +163,23 @@ class YG_EXPORT Style { YGAlign alignContent() const { return getEnumData(flags, alignContentOffset); } - BitfieldRef alignContent() { return {*this, alignContentOffset}; } + BitfieldRef alignContent() { + return {*this, alignContentOffset}; + } YGAlign alignItems() const { return getEnumData(flags, alignItemsOffset); } - BitfieldRef alignItems() { return {*this, alignItemsOffset}; } + BitfieldRef alignItems() { + return {*this, alignItemsOffset}; + } YGAlign alignSelf() const { return getEnumData(flags, alignSelfOffset); } - BitfieldRef alignSelf() { return {*this, alignSelfOffset}; } + BitfieldRef alignSelf() { + return {*this, alignSelfOffset}; + } YGPositionType positionType() const { return getEnumData(flags, positionTypeOffset); @@ -166,62 +188,118 @@ class YG_EXPORT Style { return {*this, positionTypeOffset}; } - YGWrap flexWrap() const { return getEnumData(flags, flexWrapOffset); } - BitfieldRef flexWrap() { return {*this, flexWrapOffset}; } + YGWrap flexWrap() const { + return getEnumData(flags, flexWrapOffset); + } + BitfieldRef flexWrap() { + return {*this, flexWrapOffset}; + } YGOverflow overflow() const { return getEnumData(flags, overflowOffset); } - BitfieldRef overflow() { return {*this, overflowOffset}; } + BitfieldRef overflow() { + return {*this, overflowOffset}; + } YGDisplay display() const { return getEnumData(flags, displayOffset); } - BitfieldRef display() { return {*this, displayOffset}; } + BitfieldRef display() { + return {*this, displayOffset}; + } - FloatOptional flex() const { return flex_; } - Ref flex() { return {*this}; } + FloatOptional flex() const { + return flex_; + } + Ref flex() { + return {*this}; + } - FloatOptional flexGrow() const { return flexGrow_; } - Ref flexGrow() { return {*this}; } + FloatOptional flexGrow() const { + return flexGrow_; + } + Ref flexGrow() { + return {*this}; + } - FloatOptional flexShrink() const { return flexShrink_; } - Ref flexShrink() { return {*this}; } + FloatOptional flexShrink() const { + return flexShrink_; + } + Ref flexShrink() { + return {*this}; + } - CompactValue flexBasis() const { return flexBasis_; } - Ref flexBasis() { return {*this}; } + CompactValue flexBasis() const { + return flexBasis_; + } + Ref flexBasis() { + return {*this}; + } - const Edges& margin() const { return margin_; } - IdxRef margin() { return {*this}; } + const Edges& margin() const { + return margin_; + } + IdxRef margin() { + return {*this}; + } - const Edges& position() const { return position_; } - IdxRef position() { return {*this}; } + const Edges& position() const { + return position_; + } + IdxRef position() { + return {*this}; + } - const Edges& padding() const { return padding_; } - IdxRef padding() { return {*this}; } + const Edges& padding() const { + return padding_; + } + IdxRef padding() { + return {*this}; + } - const Edges& border() const { return border_; } - IdxRef border() { return {*this}; } + const Edges& border() const { + return border_; + } + IdxRef border() { + return {*this}; + } - const Gutters& gap() const { return gap_; } - IdxRef gap() { return {*this}; } + const Gutters& gap() const { + return gap_; + } + IdxRef gap() { + return {*this}; + } - const Dimensions& dimensions() const { return dimensions_; } - IdxRef dimensions() { return {*this}; } + const Dimensions& dimensions() const { + return dimensions_; + } + IdxRef dimensions() { + return {*this}; + } - const Dimensions& minDimensions() const { return minDimensions_; } + const Dimensions& minDimensions() const { + return minDimensions_; + } IdxRef minDimensions() { return {*this}; } - const Dimensions& maxDimensions() const { return maxDimensions_; } + const Dimensions& maxDimensions() const { + return maxDimensions_; + } IdxRef maxDimensions() { return {*this}; } // Yoga specific properties, not compatible with flexbox specification - FloatOptional aspectRatio() const { return aspectRatio_; } - Ref aspectRatio() { return {*this}; } + FloatOptional aspectRatio() const { + return aspectRatio_; + } + Ref aspectRatio() { + return {*this}; + } }; YG_EXPORT bool operator==(const Style& lhs, const Style& rhs);