pmt: reformat code.

.clang-format

@@ -1,6 +1,6 @@
 ---
 Language:        Cpp
-AccessModifierOffset: -2
+AccessModifierOffset: -1
 AlignAfterOpenBracket: Align
 AlignArrayOfStructures: None
 AlignConsecutiveAssignments:
@@ -65,7 +65,7 @@ AlignConsecutiveTableGenDefinitionColons:
   AlignFunctionDeclarations: false
   AlignFunctionPointers: false
   PadOperators:    false
-AlignEscapedNewlines: Right
+AlignEscapedNewlines: Left
 AlignOperands:   Align
 AlignTrailingComments:
   Kind:            Always
@@ -79,17 +79,22 @@ AllowShortCaseLabelsOnASingleLine: false
 AllowShortCompoundRequirementOnASingleLine: true
 AllowShortEnumsOnASingleLine: true
 AllowShortFunctionsOnASingleLine: All
-AllowShortIfStatementsOnASingleLine: AllIfsAndElse
+AllowShortIfStatementsOnASingleLine: WithoutElse
 AllowShortLambdasOnASingleLine: All
-AllowShortLoopsOnASingleLine: false
+AllowShortLoopsOnASingleLine: true
 AllowShortNamespacesOnASingleLine: false
 AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakBeforeMultilineStrings: true
 AttributeMacros:
   - __capability
+  - absl_nonnull
+  - absl_nullable
+  - absl_nullability_unknown
 BinPackArguments: true
+BinPackLongBracedList: true
 BinPackParameters: BinPack
 BitFieldColonSpacing: Both
+BracedInitializerIndentWidth: -1
 BraceWrapping:
   AfterCaseLabel:  false
   AfterClass:      false
@@ -118,13 +123,14 @@ BreakBeforeBinaryOperators: None
 BreakBeforeConceptDeclarations: Always
 BreakBeforeBraces: Attach
 BreakBeforeInlineASMColon: OnlyMultiline
+BreakBeforeTemplateCloser: false
 BreakBeforeTernaryOperators: true
 BreakBinaryOperations: Never
 BreakConstructorInitializers: BeforeColon
 BreakFunctionDefinitionParameters: false
 BreakInheritanceList: BeforeColon
 BreakStringLiterals: true
-BreakTemplateDeclarations: MultiLine
+BreakTemplateDeclarations: Yes
 ColumnLimit:     80
 CommentPragmas:  '^ IWYU pragma:'
 CompactNamespaces: false
@@ -135,6 +141,7 @@ DerivePointerAlignment: false
 DisableFormat:   false
 EmptyLineAfterAccessModifier: Never
 EmptyLineBeforeAccessModifier: LogicalBlock
+EnumTrailingComma: Leave
 ExperimentalAutoDetectBinPacking: false
 FixNamespaceComments: true
 ForEachMacros:
@@ -143,25 +150,29 @@ ForEachMacros:
   - BOOST_FOREACH
 IfMacros:
   - KJ_IF_MAYBE
-IncludeBlocks:   Preserve
+IncludeBlocks:   Regroup
 IncludeCategories:
-  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+  - Regex:           '^<ext/.*\.h>'
     Priority:        2
     SortPriority:    0
     CaseSensitive:   false
-  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+  - Regex:           '^<.*\.h>'
-    Priority:        3
-    SortPriority:    0
-    CaseSensitive:   false
-  - Regex:           '.*'
     Priority:        1
     SortPriority:    0
     CaseSensitive:   false
-IncludeIsMainRegex: '(Test)?$'
+  - Regex:           '^<.*'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '([-_](test|unittest))?$'
 IncludeIsMainSourceRegex: ''
 IndentAccessModifiers: false
 IndentCaseBlocks: false
-IndentCaseLabels: false
+IndentCaseLabels: true
 IndentExportBlock: true
 IndentExternBlock: AfterExternBlock
 IndentGotoLabels: true
@@ -183,7 +194,7 @@ JavaScriptQuotes: Leave
 JavaScriptWrapImports: true
 KeepEmptyLines:
   AtEndOfFile:     false
-  AtStartOfBlock:  true
+  AtStartOfBlock:  false
   AtStartOfFile:   true
 KeepFormFeed:    false
 LambdaBodyIndentation: Signature
@@ -193,14 +204,15 @@ MacroBlockEnd:   ''
 MainIncludeChar: Quote
 MaxEmptyLinesToKeep: 1
 NamespaceIndentation: None
-ObjCBinPackProtocolList: Auto
+ObjCBinPackProtocolList: Never
 ObjCBlockIndentWidth: 2
 ObjCBreakBeforeNestedBlockParam: true
 ObjCSpaceAfterProperty: false
 ObjCSpaceBeforeProtocolList: true
-PackConstructorInitializers: BinPack
+OneLineFormatOffRegex: ''
+PackConstructorInitializers: NextLine
 PenaltyBreakAssignment: 2
-PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakBeforeFirstCallParameter: 1
 PenaltyBreakBeforeMemberAccess: 150
 PenaltyBreakComment: 300
 PenaltyBreakFirstLessLess: 120
@@ -210,10 +222,40 @@ PenaltyBreakString: 1000
 PenaltyBreakTemplateDeclaration: 10
 PenaltyExcessCharacter: 1000000
 PenaltyIndentedWhitespace: 0
-PenaltyReturnTypeOnItsOwnLine: 60
+PenaltyReturnTypeOnItsOwnLine: 200
-PointerAlignment: Right
+PointerAlignment: Left
 PPIndentWidth:   -1
 QualifierAlignment: Leave
+RawStringFormats:
+  - Language:        Cpp
+    Delimiters:
+      - cc
+      - CC
+      - cpp
+      - Cpp
+      - CPP
+      - 'c++'
+      - 'C++'
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+  - Language:        TextProto
+    Delimiters:
+      - pb
+      - PB
+      - proto
+      - PROTO
+    EnclosingFunctions:
+      - EqualsProto
+      - EquivToProto
+      - PARSE_PARTIAL_TEXT_PROTO
+      - PARSE_TEST_PROTO
+      - PARSE_TEXT_PROTO
+      - ParseTextOrDie
+      - ParseTextProtoOrDie
+      - ParseTestProto
+      - ParsePartialTestProto
+    CanonicalDelimiter: pb
+    BasedOnStyle:    google
 ReferenceAlignment: Pointer
 ReflowComments:  Always
 RemoveBracesLLVM: false
@@ -225,11 +267,14 @@ RequiresExpressionIndentation: OuterScope
 SeparateDefinitionBlocks: Leave
 ShortNamespaceLines: 1
 SkipMacroDefinitionBody: false
-SortIncludes:    CaseSensitive
+SortIncludes:
+  Enabled:         true
+  IgnoreCase:      false
 SortJavaStaticImport: Before
 SortUsingDeclarations: LexicographicNumeric
 SpaceAfterCStyleCast: false
 SpaceAfterLogicalNot: false
+SpaceAfterOperatorKeyword: false
 SpaceAfterTemplateKeyword: true
 SpaceAroundPointerQualifiers: Default
 SpaceBeforeAssignmentOperators: true
@@ -245,6 +290,7 @@ SpaceBeforeParensOptions:
   AfterFunctionDefinitionName: false
   AfterFunctionDeclarationName: false
   AfterIfMacros:   true
+  AfterNot:        false
   AfterOverloadedOperator: false
   AfterPlacementOperator: true
   AfterRequiresInClause: false
@@ -253,7 +299,7 @@ SpaceBeforeParensOptions:
 SpaceBeforeRangeBasedForLoopColon: true
 SpaceBeforeSquareBrackets: false
 SpaceInEmptyBlock: false
-SpacesBeforeTrailingComments: 1
+SpacesBeforeTrailingComments: 2
 SpacesInAngles:  Never
 SpacesInContainerLiterals: true
 SpacesInLineCommentPrefix:
@@ -267,7 +313,7 @@ SpacesInParensOptions:
   InEmptyParentheses: false
   Other:           false
 SpacesInSquareBrackets: false
-Standard:        Latest
+Standard:        Auto
 StatementAttributeLikeMacros:
   - Q_EMIT
 StatementMacros:

include/PartitionManager/PartitionManager.hpp

@@ -82,7 +82,8 @@ public:
 };
 
 // A class for function management.
-template <class _Type> class basic_manager {
+template <class _Type>
+class basic_manager {
  private:
   std::vector<std::unique_ptr<_Type>> _functions;
 

src/FunctionManager.cpp

@@ -14,9 +14,10 @@
    limitations under the License.
 */
 
+#include <fcntl.h>
+
 #include <PartitionManager/PartitionManager.hpp>
 #include <algorithm>
-#include <fcntl.h>
 #include <memory>
 #include <string>
 #include <unordered_set>
@@ -42,13 +43,15 @@ std::vector<std::string> splitIfHasDelim(const std::string &s, const char delim,
 
 void setupBufferSize(uint64_t& size, const std::string& entry) {
   if (PART_MAP.hasPartition(entry) && PART_MAP.sizeOf(entry) % size != 0) {
-    println("%sWARNING%s: Specified buffer size is invalid for %s! Using "
+    println(
+        "%sWARNING%s: Specified buffer size is invalid for %s! Using "
         "different buffer size for %s.",
         YELLOW, STYLE_RESET, entry.data(), entry.data());
     size = PART_MAP.sizeOf(entry) % 4096 == 0 ? 4096 : 1;
   } else if (Helper::fileIsExists(entry)) {
     if (Helper::fileSize(entry) % size != 0) {
-      println("%sWARNING%s: Specified buffer size is invalid for %s! using "
+      println(
+          "%sWARNING%s: Specified buffer size is invalid for %s! using "
           "different buffer size for %s.",
           YELLOW, STYLE_RESET, entry.data(), entry.data());
       size = Helper::fileSize(entry) % 4096 == 0 ? 4096 : 1;

src/PartitionManager.cpp

@@ -14,18 +14,20 @@
    limitations under the License.
 */
 
-#include "functions/functions.hpp"
 #include <PartitionManager/PartitionManager.hpp>
 #include <csignal>
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
+
+#include "functions/functions.hpp"
 #ifndef ANDROID_BUILD
 #include <generated/buildInfo.hpp>
 #endif
-#include <string>
 #include <unistd.h>
 
+#include <string>
+
 namespace PartitionManager {
 
 /**
@@ -37,8 +39,11 @@ namespace PartitionManager {
   FuncManager.registerFunction(std::make_unique<cls>(), AppMain)
 
 basic_variables::basic_variables()
-    : logFile(Helper::LoggingProperties::FILE), onLogical(false),
+    : logFile(Helper::LoggingProperties::FILE),
-      quietProcess(false), verboseMode(false), viewVersion(false),
+      onLogical(false),
+      quietProcess(false),
+      verboseMode(false),
+      viewVersion(false),
       forceProcess(false) {
   try {
     PartMap = std::make_unique<PartitionMap::BuildMap>();
@@ -63,7 +68,8 @@ static int write(void *cookie, const char *buf, const int size) {
     const int ret = fwrite(buf, 1, static_cast<size_t>(size), real);
     fflush(real);
     return ret;
-  } else return size;
+  } else
+    return size;
 }
 
 static FILE* make_fp(FILE* real) {
@@ -111,7 +117,8 @@ int Main(int argc, char **argv) {
 
     AppMain.fallthrough(true);
     AppMain.set_help_all_flag("--help-all", "Print full help message and exit");
-    AppMain.footer("Partition Manager Tool is written by YZBruh\n"
+    AppMain.footer(
+        "Partition Manager Tool is written by YZBruh\n"
         "This project licensed under "
         "Apache 2.0 license\nReport "
         "bugs to https://github.com/ShawkTeam/pmt-renovated/issues");
@@ -159,15 +166,18 @@ int Main(int argc, char **argv) {
 
     if (FuncManager.hasFlagOnUsedFunction(NO_MAP_CHECK)) {
       if (!VARS.searchPath.empty())
-        WARNING("-S (--search-path) flag is ignored. Because, don't needed "
+        WARNING(
+            "-S (--search-path) flag is ignored. Because, don't needed "
             "partition map by your used function.\n");
       if (VARS.onLogical)
-        WARNING("-l (--logical) flag ignored. Because, partition type don't "
+        WARNING(
+            "-l (--logical) flag ignored. Because, partition type don't "
             "needed by your used function.\n");
     } else {
       if (!VARS.searchPath.empty()) (PART_MAP)(VARS.searchPath);
       if (!VARS.PartMap && VARS.searchPath.empty())
-        throw Error("No default search entries were found. Specify a search "
+        throw Error(
+            "No default search entries were found. Specify a search "
             "directory with -S "
             "(--search-path)");
 

src/functions/BackupFunction.cpp

@@ -14,15 +14,17 @@
    limitations under the License.
 */
 
-#include "functions.hpp"
+#include <fcntl.h>
+#include <private/android_filesystem_config.h>
+#include <unistd.h>
+
 #include <PartitionManager/PartitionManager.hpp>
 #include <cerrno>
 #include <chrono>
 #include <cstdlib>
-#include <fcntl.h>
 #include <future>
-#include <private/android_filesystem_config.h>
+
-#include <unistd.h>
+#include "functions.hpp"
 
 #define BFUN "backupFunction"
 #define FUNCTION_CLASS backupFunction
@@ -153,7 +155,8 @@ RUN {
     if (!snd) {
       end += fst + '\n';
       endResult = false;
-    } else println("%s", fst.c_str());
+    } else
+      println("%s", fst.c_str());
   }
 
   if (!endResult) throw Error("%s", end.c_str());

src/functions/CleanLogFunction.cpp

@@ -14,9 +14,10 @@ Copyright 2025 Yağız Zengin
    limitations under the License.
 */
 
-#include "functions.hpp"
 #include <PartitionManager/PartitionManager.hpp>
 
+#include "functions.hpp"
+
 #define CFUN "cleanLogFunction"
 #define FUNCTION_CLASS cleanLogFunction
 

src/functions/EraseFunction.cpp

@@ -14,12 +14,14 @@ Copyright 2025 Yağız Zengin
    limitations under the License.
 */
 
-#include "functions.hpp"
+#include <fcntl.h>
+#include <unistd.h>
+
 #include <PartitionManager/PartitionManager.hpp>
 #include <cerrno>
-#include <fcntl.h>
 #include <future>
-#include <unistd.h>
+
+#include "functions.hpp"
 
 #define EFUN "eraseFunction"
 #define FUNCTION_CLASS eraseFunction
@@ -81,7 +83,8 @@ RUN_ASYNC(const std::string &partitionName, const uint64_t bufferSize) {
       return {Helper::format("Can't write zero bytes to partition: %s: %s",
                              partitionName.data(), strerror(errno)),
               false};
-    else bytesWritten += result;
+    else
+      bytesWritten += result;
   }
 
   return {Helper::format("Successfully wrote zero bytes to the %s partition",
@@ -120,7 +123,8 @@ RUN {
     if (!snd) {
       end += fst + '\n';
       endResult = false;
-    } else println("%s", fst.c_str());
+    } else
+      println("%s", fst.c_str());
   }
 
   if (!endResult) throw Error("%s", end.c_str());

src/functions/FlashFunction.cpp

@@ -14,13 +14,15 @@ Copyright 2025 Yağız Zengin
    limitations under the License.
 */
 
-#include "functions.hpp"
+#include <fcntl.h>
+#include <unistd.h>
+
 #include <PartitionManager/PartitionManager.hpp>
 #include <cerrno>
 #include <cstdlib>
-#include <fcntl.h>
 #include <future>
-#include <unistd.h>
+
+#include "functions.hpp"
 
 #define FFUN "flashFunction"
 #define FUNCTION_CLASS flashFunction
@@ -151,7 +153,8 @@ RUN {
     if (!snd) {
       end += fst + '\n';
       endResult = false;
-    } else println("%s", fst.c_str());
+    } else
+      println("%s", fst.c_str());
   }
 
   if (!endResult) throw Error("%s", end.c_str());

src/functions/InfoFunction.cpp

@@ -14,13 +14,15 @@ Copyright 2025 Yağız Zengin
    limitations under the License.
 */
 
-#include "functions.hpp"
+#include <fcntl.h>
+
 #include <PartitionManager/PartitionManager.hpp>
 #include <cerrno>
 #include <cstdlib>
-#include <fcntl.h>
 #include <nlohmann/json.hpp>
 
+#include "functions.hpp"
+
 #define IFUN "infoFunction"
 #define FUNCTION_CLASS infoFunction
 
@@ -30,7 +32,8 @@ INIT {
   LOGN(IFUN, INFO) << "Initializing variables of info printer function."
                    << std::endl;
   cmd = _app.add_subcommand("info", "Tell info(s) of input partition list")
-            ->footer("Use get-all or getvar-all as partition name for getting "
+            ->footer(
+                "Use get-all or getvar-all as partition name for getting "
                 "info's of all partitions.\nUse get-logicals as partition "
                 "name for getting info's of logical partitions.\n"
                 "Use get-physical as partition name for getting info's of "
@@ -103,7 +106,8 @@ RUN {
     PART_MAP.doForLogicalPartitions(func);
   else if (partitions.back() == "get-physicals")
     PART_MAP.doForPhysicalPartitions(func);
-  else PART_MAP.doForPartitionList(partitions, func);
+  else
+    PART_MAP.doForPartitionList(partitions, func);
 
   if (jsonFormat) {
     nlohmann::json j;

src/functions/MemoryTestFunction.cpp

@@ -14,14 +14,16 @@ Copyright 2025 Yağız Zengin
    limitations under the License.
 */
 
-#include "functions.hpp"
+#include <fcntl.h>
+#include <unistd.h>
+
 #include <PartitionManager/PartitionManager.hpp>
 #include <chrono>
 #include <cstdlib>
 #include <cstring>
-#include <fcntl.h>
 #include <random>
-#include <unistd.h>
+
+#include "functions.hpp"
 
 #define MTFUN "memoryTestFunction"
 #define FUNCTION_CLASS memoryTestFunction

src/functions/PartitionSizeFunction.cpp

@@ -14,9 +14,10 @@ Copyright 2025 Yağız Zengin
    limitations under the License.
 */
 
-#include "functions.hpp"
 #include <PartitionManager/PartitionManager.hpp>
 
+#include "functions.hpp"
+
 #define SFUN "partitionSizeFunction"
 #define FUNCTION_CLASS partitionSizeFunction
 
@@ -26,7 +27,8 @@ INIT {
       << "Initializing variables of partition size getter function."
       << std::endl;
   cmd = _app.add_subcommand("sizeof", "Tell size(s) of input partition list")
-            ->footer("Use get-all or getvar-all as partition name for getting "
+            ->footer(
+                "Use get-all or getvar-all as partition name for getting "
                 "sizes of all partitions.\nUse get-logicals as partition "
                 "name for getting sizes of logical partitions.\n"
                 "Use get-physical as partition name for getting sizes of "
@@ -72,7 +74,8 @@ RUN {
                     partition.data());
     }
 
-    if (onlySize) println("%d", Helper::convertTo(props.size, multiple));
+    if (onlySize)
+      println("%d", Helper::convertTo(props.size, multiple));
     else
       println("%s: %d%s", partition.data(),
               Helper::convertTo(props.size, multiple),
@@ -87,7 +90,8 @@ RUN {
     PART_MAP.doForLogicalPartitions(func);
   else if (partitions.back() == "get-physicals")
     PART_MAP.doForPhysicalPartitions(func);
-  else PART_MAP.doForPartitionList(partitions, func);
+  else
+    PART_MAP.doForPartitionList(partitions, func);
 
   return true;
 }

src/functions/RealPathFunction.cpp

@@ -14,9 +14,10 @@
    limitations under the License.
 */
 
-#include "functions.hpp"
 #include <PartitionManager/PartitionManager.hpp>
 
+#include "functions.hpp"
+
 #define RPFUN "realPathFunction"
 #define FUNCTION_CLASS realPathFunction
 
@@ -51,7 +52,8 @@ RUN {
 
     if (realLinkPath)
       println("%s", PART_MAP.getRealLinkPathOf(partition).data());
-    else println("%s", PART_MAP.getRealPathOf(partition).data());
+    else
+      println("%s", PART_MAP.getRealPathOf(partition).data());
   }
 
   return true;

src/functions/RebootFunction.cpp

@@ -14,9 +14,10 @@ Copyright 2025 Yağız Zengin
    limitations under the License.
 */
 
-#include "functions.hpp"
 #include <PartitionManager/PartitionManager.hpp>
 
+#include "functions.hpp"
+
 #define RFUN "rebootFunction"
 #define FUNCTION_CLASS rebootFunction
 
@@ -35,8 +36,10 @@ RUN {
                    << (rebootTarget.empty() ? "none" : rebootTarget)
                    << std::endl;
 
-  if (Helper::androidReboot(rebootTarget)) println("Reboot command was sent");
+  if (Helper::androidReboot(rebootTarget))
-  else throw Error("Cannot reboot device");
+    println("Reboot command was sent");
+  else
+    throw Error("Cannot reboot device");
 
   return true;
 }

src/functions/TypeFunction.cpp

@@ -14,10 +14,11 @@
    limitations under the License.
 */
 
-#include "functions.hpp"
 #include <PartitionManager/PartitionManager.hpp>
 #include <map>
 
+#include "functions.hpp"
+
 #define TFUN "typeFunction"
 #define FUNCTION_CLASS typeFunction
 
@@ -47,7 +48,8 @@ RUN {
     magics.merge(PartitionMap::Extras::AndroidMagicMap);
   else if (onlyCheckFileSystemMagics)
     magics.merge(PartitionMap::Extras::FileSystemMagicMap);
-  else magics.merge(PartitionMap::Extras::MagicMap);
+  else
+    magics.merge(PartitionMap::Extras::MagicMap);
 
   for (const auto& content : contents) {
     if (!PART_MAP.hasPartition(content) && !Helper::fileIsExists(content))

srclib/libhelper/include/libhelper/lib.hpp

@@ -17,8 +17,9 @@
 #ifndef LIBHELPER_LIB_HPP
 #define LIBHELPER_LIB_HPP
 
-#include <cstdint>
 #include <dirent.h>
+
+#include <cstdint>
 #include <exception>
 #include <functional>
 #include <optional>
@@ -86,7 +87,8 @@ public:
 
   ~Logger();
 
-  template <typename T> Logger &operator<<(const T &msg) {
+  template <typename T>
+  Logger& operator<<(const T& msg) {
     _oss << msg;
     return *this;
   }
@@ -106,7 +108,8 @@ private:
  public:
   ~garbageCollector();
 
-  template <typename T> void delAfterProgress(T *_ptr) {
+  template <typename T>
+  void delAfterProgress(T* _ptr) {
     _cleaners.push_back([_ptr] { delete[] _ptr; });
   }
 
@@ -130,12 +133,10 @@ public:
 
     if constexpr (d > 0) {
       std::uniform_int_distribution<> dist(0, (max - start - 1) / d);
-      while (set.size() < count)
+      while (set.size() < count) set.insert(start + dist(gen) * d);
-        set.insert(start + dist(gen) * d);
     } else {
       std::uniform_int_distribution<> dist(start, max - 1);
-      while (set.size() < count)
+      while (set.size() < count) set.insert(dist(gen));
-        set.insert(dist(gen));
     }
 
     return set;
@@ -158,15 +159,15 @@ public:
   }
 };
 
-template <typename _Type1, typename _Type2, typename _Type3> class PureTuple {
+template <typename _Type1, typename _Type2, typename _Type3>
+class PureTuple {
  private:
   void expand_if_needed() {
     if (count == capacity) {
       capacity *= 2;
       Data* data = new Data[capacity];
 
-      for (size_t i = 0; i < count; i++)
+      for (size_t i = 0; i < count; i++) data[i] = tuple_data[i];
-        data[i] = tuple_data[i];
 
       delete[] tuple_data;
       tuple_data = data;
@@ -179,8 +180,8 @@ public:
     _Type2 second;
     _Type3 third;
 
-    bool
+    bool operator==(
-    operator==(const std::tuple<_Type1, _Type2, _Type3> &t) const noexcept {
+        const std::tuple<_Type1, _Type2, _Type3>& t) const noexcept {
       return first == std::get<0>(t) && second == std::get<1>(t) &&
              third == std::get<2>(t);
     }
@@ -223,16 +224,17 @@ public:
 
   PureTuple(std::initializer_list<Data> val)
       : tuple_data(new Data[20]), capacity(20), count(0) {
-    for (const auto &v : val)
+    for (const auto& v : val) insert(v);
-      insert(v);
   }
   PureTuple(PureTuple& other)
-      : tuple_data(new Data[other.capacity]), capacity(other.capacity),
+      : tuple_data(new Data[other.capacity]),
+        capacity(other.capacity),
         count(other.count) {
     std::copy(other.tuple_data, other.tuple_data + count, tuple_data);
   }
   PureTuple(PureTuple&& other) noexcept
-      : tuple_data(new Data[other.capacity]), capacity(other.capacity),
+      : tuple_data(new Data[other.capacity]),
+        capacity(other.capacity),
         count(other.count) {
     std::copy(other.tuple_data, other.tuple_data + count, tuple_data);
     other.clear();
@@ -343,8 +345,7 @@ public:
   }
 
   void merge(const PureTuple& other) noexcept {
-    for (const auto &v : other)
+    for (const auto& v : other) insert(v);
-      insert(v);
   }
 
   void pop_back() noexcept {
@@ -481,7 +482,8 @@ public:
 };
 
 // Provides a capsule structure to store variable references and values.
-template <typename _Type> class Capsule : public garbageCollector {
+template <typename _Type>
+class Capsule : public garbageCollector {
  public:
   _Type& value;
 
@@ -563,13 +565,19 @@ void set(std::string_view name, std::string_view file);
 void setProgramName(std::string_view name);
 void setLogFile(std::string_view file);
 
-template <int state> void setPrinting() {
+template <int state>
-  if (state == 1 || state == 0) PRINT = state;
+void setPrinting() {
-  else PRINT = NO;
+  if (state == 1 || state == 0)
+    PRINT = state;
+  else
+    PRINT = NO;
 }
-template <int state> void setLoggingState() {
+template <int state>
-  if (state == 1 || state == 0) DISABLE = state;
+void setLoggingState() {
-  else DISABLE = NO;
+  if (state == 1 || state == 0)
+    DISABLE = state;
+  else
+    DISABLE = NO;
 }
 
 void reset();
@@ -809,7 +817,8 @@ __attribute__((format(printf, 1, 2))) std::string format(const char *format,
 /**
  * Convert input size to input multiple
  */
-template <uint64_t size> int convertTo(const sizeCastTypes type) {
+template <uint64_t size>
+int convertTo(const sizeCastTypes type) {
   if (type == KB) return TO_KB(size);
   if (type == MB) return TO_MB(size);
   if (type == GB) return TO_GB(size);

srclib/libhelper/src/Checkers.cpp

@@ -14,13 +14,14 @@
    limitations under the License.
 */
 
-#include <cstdio>
-#include <cstdlib>
-#include <libhelper/lib.hpp>
 #include <private/android_filesystem_config.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
+#include <cstdio>
+#include <cstdlib>
+#include <libhelper/lib.hpp>
+
 namespace Helper {
 bool hasSuperUser() { return (getuid() == AID_ROOT); }
 bool hasAdbPermissions() { return (getuid() == AID_SHELL); }

srclib/libhelper/src/Classes.cpp

@@ -14,19 +14,20 @@
    limitations under the License.
 */
 
+#include <dirent.h>
+#include <fcntl.h>
+#include <libgen.h>
+#include <unistd.h>
+
 #include <cerrno>
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <dirent.h>
 #include <exception>
-#include <fcntl.h>
 #include <functional>
-#include <libgen.h>
 #include <libhelper/lib.hpp>
 #include <sstream>
-#include <unistd.h>
 
 namespace Helper {
 Error::Error(const char* format, ...) {
@@ -43,8 +44,12 @@ const char *Error::what() const noexcept { return _message.data(); }
 
 Logger::Logger(const LogLevels level, const char* func, const char* file,
                const char* name, const char* source_file, const int line)
-    : _level(level), _function_name(func), _logFile(file), _program_name(name),
+    : _level(level),
-      _file(source_file), _line(line) {}
+      _function_name(func),
+      _logFile(file),
+      _program_name(name),
+      _file(source_file),
+      _line(line) {}
 
 Logger::~Logger() {
   if (LoggingProperties::DISABLE) return;
@@ -97,16 +102,11 @@ Logger &Logger::operator<<(std::ostream &(*msg)(std::ostream &)) {
 }
 
 garbageCollector::~garbageCollector() {
-  for (auto &ptr_func : _cleaners)
+  for (auto& ptr_func : _cleaners) ptr_func();
-    ptr_func();
+  for (const auto& fd : _fds) close(fd);
-  for (const auto &fd : _fds)
+  for (const auto& fp : _fps) fclose(fp);
-    close(fd);
+  for (const auto& dp : _dps) closedir(dp);
-  for (const auto &fp : _fps)
+  for (const auto& file : _files) eraseEntry(file);
-    fclose(fp);
-  for (const auto &dp : _dps)
-    closedir(dp);
-  for (const auto &file : _files)
-    eraseEntry(file);
 }
 
 void garbageCollector::delFileAfterProgress(const std::string& _path) {

srclib/libhelper/src/FileUtil.cpp

@@ -14,16 +14,17 @@
    limitations under the License.
 */
 
+#include <dirent.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
 #include <cerrno>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <dirent.h>
-#include <fcntl.h>
 #include <libhelper/lib.hpp>
 #include <string>
-#include <sys/stat.h>
-#include <unistd.h>
 
 namespace Helper {
 bool writeFile(const std::string_view file, const std::string_view text) {
@@ -48,8 +49,7 @@ std::optional<std::string> readFile(const std::string_view file) {
 
   char buffer[1024];
   std::string str;
-  while (fgets(buffer, sizeof(buffer), fp))
+  while (fgets(buffer, sizeof(buffer), fp)) str += buffer;
-    str += buffer;
 
   LOGN(HELPER, INFO) << "read " << file << " successfully, read text: \"" << str
                      << "\"" << std::endl;

srclib/libhelper/src/Sha256.cpp

@@ -14,13 +14,14 @@
    limitations under the License.
 */
 
+#include <picosha2.h>
+#include <sys/stat.h>
+
 #include <fstream>
 #include <iostream>
 #include <libhelper/lib.hpp>
 #include <optional>
-#include <picosha2.h>
 #include <string>
-#include <sys/stat.h>
 #include <vector>
 
 namespace Helper {

srclib/libhelper/src/Utilities.cpp

@@ -14,28 +14,31 @@
    limitations under the License.
 */
 
+#include <cutils/android_reboot.h>
+#include <fcntl.h>
+
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
-#include <cutils/android_reboot.h>
-#include <fcntl.h>
 #ifndef ANDROID_BUILD
-#include <generated/buildInfo.hpp>
 #include <sys/_system_properties.h>
+
+#include <generated/buildInfo.hpp>
 #else
 #include <sys/system_properties.h>
 #endif
-#include <cstdarg>
 #include <cutils/android_reboot.h>
-#include <iostream>
 #include <libgen.h>
+#include <sys/_system_properties.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <cstdarg>
+#include <iostream>
 #include <libhelper/lib.hpp>
 #include <memory>
 #include <string>
 #include <string_view>
-#include <sys/_system_properties.h>
-#include <sys/stat.h>
-#include <unistd.h>
 
 #ifdef __ANDROID__
 // From system/core/libcutils/android_reboot.cpp android16-s2-release
@@ -58,8 +61,10 @@ int android_reboot(const unsigned cmd, int /*flags*/, const char *arg) {
   }
 
   if (!restart_cmd) return -1;
-  if (arg && arg[0]) ret = asprintf(&prop_value, "%s,%s", restart_cmd, arg);
+  if (arg && arg[0])
-  else ret = asprintf(&prop_value, "%s", restart_cmd);
+    ret = asprintf(&prop_value, "%s,%s", restart_cmd, arg);
+  else
+    ret = asprintf(&prop_value, "%s", restart_cmd);
 
   if (ret < 0) return -1;
   ret = __system_property_set(ANDROID_RB_PROPERTY, prop_value);

srclib/libhelper/tests/test.cpp

@@ -51,11 +51,13 @@ int main(int argc, char **argv) {
 
     if (!Helper::writeFile("file.txt", "hello world"))
       throw Helper::Error("Cannot write \"hello world\" in 'file.txt'");
-    else std::cout << "file.txt writed." << std::endl;
+    else
+      std::cout << "file.txt writed." << std::endl;
 
     if (const auto content = Helper::readFile("file.txt"); !content)
       throw Helper::Error("Cannot read 'file.txt'");
-    else std::cout << "'file.txt': " << *content << std::endl;
+    else
+      std::cout << "'file.txt': " << *content << std::endl;
 
     std::cout << "Making directory 'dir2': " << std::boolalpha
               << Helper::makeDirectory(test_path("dir2")) << std::endl;
@@ -80,7 +82,8 @@ int main(int argc, char **argv) {
 
     if (const auto sha256 = Helper::sha256Of(test_path("file2.txt")); !sha256)
       throw Helper::Error("Cannot get sha256 of 'file2.txt'");
-    else std::cout << "SHA256 of 'file2.txt': " << *sha256 << std::endl;
+    else
+      std::cout << "SHA256 of 'file2.txt': " << *sha256 << std::endl;
 
     std::cout << "'file2.txt' and 'file2lnk.txt' same? (SHA256): "
               << std::boolalpha

srclib/libpartition_map/include/libpartition_map/lib.hpp

@@ -98,8 +98,7 @@ public:
 
     explicit iterator(_entry* p);
 
-    auto operator*() const
+    auto operator*() const -> std::pair<std::string&, decltype(_entry::props)&>;
-        -> std::pair<std::string &, decltype(_entry::props) &>;
     _entry* operator->() const;
     iterator& operator++();
     iterator operator++(int);
@@ -174,8 +173,8 @@ public:
    *   Map_temp_t type. If the partition is not in the
    *   currently created list, returns std::nullopt.
    */
-  [[nodiscard]] std::optional<std::pair<uint64_t, bool>>
+  [[nodiscard]] std::optional<std::pair<uint64_t, bool>> get(
-  get(std::string_view name) const;
+      std::string_view name) const;
 
   /**
    *   If there is a logical partition(s) in the created
@@ -183,16 +182,16 @@ public:
    *   data of type std::string). If there is no logical
    *   partition in the created list, it returns std::nullopt.
    */
-  [[nodiscard]] std::optional<std::list<std::string>>
+  [[nodiscard]] std::optional<std::list<std::string>> getLogicalPartitionList()
-  getLogicalPartitionList() const;
+      const;
 
   /**
    *   The physical partitions in the created list are
    *   returned as std::list type. If there is no content
    *   due to any problem, returns std::nullopt.
    */
-  [[nodiscard]] std::optional<std::list<std::string>>
+  [[nodiscard]] std::optional<std::list<std::string>> getPhysicalPartitionList()
-  getPhysicalPartitionList() const;
+      const;
 
   /**
    *   The partitions in the created list are returned as std::list

srclib/libpartition_map/src/Getters.cpp

@@ -25,8 +25,8 @@ Map_t basic_partition_map_builder::getAll() const {
   return _current_map;
 }
 
-std::optional<std::pair<uint64_t, bool>>
+std::optional<std::pair<uint64_t, bool>> basic_partition_map_builder::get(
-basic_partition_map_builder::get(const std::string_view name) const {
+    const std::string_view name) const {
   _map_build_check();
 
   if (!_current_map.find(name)) return std::nullopt;
@@ -63,8 +63,7 @@ basic_partition_map_builder::getPartitionList() const {
   _map_build_check();
 
   std::list<std::string> partitions;
-  for (const auto &[name, props] : _current_map)
+  for (const auto& [name, props] : _current_map) partitions.push_back(name);
-    partitions.push_back(name);
 
   if (partitions.empty()) return std::nullopt;
   return partitions;
@@ -78,8 +77,8 @@ std::string basic_partition_map_builder::getRealLinkPathOf(
   return std::string(_workdir + "/" + name.data());
 }
 
-std::string
+std::string basic_partition_map_builder::getRealPathOf(
-basic_partition_map_builder::getRealPathOf(const std::string_view name) const {
+    const std::string_view name) const {
   _map_build_check();
 
   const std::string full = (isLogical(name))

srclib/libpartition_map/src/Magic.cpp

@@ -15,12 +15,13 @@
 */
 
 #include <fcntl.h>
+#include <unistd.h>
+
 #include <libhelper/lib.hpp>
 #include <libpartition_map/lib.hpp>
 #include <map>
 #include <sstream>
 #include <string>
-#include <unistd.h>
 
 #include "PartitionManager/PartitionManager.hpp"
 

srclib/libpartition_map/src/PartitionMap.cpp

@@ -14,24 +14,26 @@
    limitations under the License.
 */
 
+#include <fcntl.h>
+
 #include <algorithm>
 #include <array>
 #include <cerrno>
 #include <cstring>
-#include <fcntl.h>
 #include <filesystem>
 #ifndef ANDROID_BUILD
 #include <generated/buildInfo.hpp>
 #endif
-#include <iostream>
-#include <libpartition_map/lib.hpp>
 #include <linux/fs.h>
-#include <memory>
-#include <string>
-#include <string_view>
 #include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <unistd.h>
+
+#include <iostream>
+#include <libpartition_map/lib.hpp>
+#include <memory>
+#include <string>
+#include <string_view>
 #include <vector>
 
 static constexpr std::array<std::string_view, 3> defaultEntryList = {
@@ -149,8 +151,10 @@ basic_partition_map_builder::basic_partition_map_builder(
   if (std::filesystem::exists(path)) {
     if (!_is_real_block_dir(path)) return;
     _current_map = _build_map(path);
-    if (_current_map.empty()) _any_generating_error = true;
+    if (_current_map.empty())
-    else _workdir = path;
+      _any_generating_error = true;
+    else
+      _workdir = path;
   } else
     throw Error("Cannot find directory: %s. Cannot build partition map!",
                 path.data());
@@ -205,7 +209,8 @@ bool basic_partition_map_builder::readDirectory(const std::string_view path) {
     if (_current_map.empty()) {
       _any_generating_error = true;
       return false;
-    } else _workdir = path;
+    } else
+      _workdir = path;
   } else
     throw Error("Cannot find directory: %s. Cannot build partition map!",
                 path.data());
@@ -250,8 +255,7 @@ bool basic_partition_map_builder::copyPartitionsToVector(
     return false;
   }
   vec.clear();
-  for (const auto &[name, props] : _current_map)
+  for (const auto& [name, props] : _current_map) vec.push_back(name);
-    vec.push_back(name);
   return true;
 }
 
@@ -268,7 +272,8 @@ bool basic_partition_map_builder::copyLogicalPartitionsToVector(
   if (vec2.empty()) {
     LOGN(MAP, ERROR) << "Cannot find logical partitions in current map.";
     return false;
-  } else vec = vec2;
+  } else
+    vec = vec2;
   return true;
 }
 
@@ -285,7 +290,8 @@ bool basic_partition_map_builder::copyPhysicalPartitionsToVector(
   if (vec2.empty()) {
     LOGN(MAP, ERROR) << "Cannot find physical partitions in current map.";
     return false;
-  } else vec = vec2;
+  } else
+    vec = vec2;
   return true;
 }
 
@@ -379,8 +385,8 @@ bool basic_partition_map_builder::doForPartitionList(
   return err;
 }
 
-uint64_t
+uint64_t basic_partition_map_builder::sizeOf(
-basic_partition_map_builder::sizeOf(const std::string_view name) const {
+    const std::string_view name) const {
   _map_build_check();
   return _current_map.get_size(name);
 }
@@ -419,8 +425,8 @@ Info basic_partition_map_builder::operator[](const int index) const {
   return _current_map[index];
 }
 
-BasicInf
+BasicInf basic_partition_map_builder::operator[](
-basic_partition_map_builder::operator[](const std::string_view &name) const {
+    const std::string_view& name) const {
   return _current_map[name];
 }
 

srclib/libpartition_map/src/Type.cpp

@@ -87,8 +87,7 @@ void basic_partition_map::_resize_map() {
   const size_t new_capacity = _capacity * 2;
   auto* new_data = new _entry[new_capacity];
 
-  for (size_t i = 0; i < _count; i++)
+  for (size_t i = 0; i < _count; i++) new_data[i] = _data[i];
-    new_data[i] = _data[i];
 
   delete[] _data;
   _data = new_data;
@@ -111,13 +110,15 @@ basic_partition_map::basic_partition_map(const std::string &name,
 }
 
 basic_partition_map::basic_partition_map(const basic_partition_map& other)
-    : _data(new _entry[other._capacity]), _count(other._count),
+    : _data(new _entry[other._capacity]),
+      _count(other._count),
       _capacity(other._capacity) {
   std::copy(other._data, other._data + _count, _data);
 }
 
 basic_partition_map::basic_partition_map(basic_partition_map&& other) noexcept
-    : _data(new _entry[other._capacity]), _count(other._count),
+    : _data(new _entry[other._capacity]),
+      _count(other._count),
       _capacity(other._capacity) {
   std::copy(other._data, other._data + _count, _data);
   other.clear();
@@ -162,8 +163,8 @@ bool basic_partition_map::is_logical(const std::string_view name) const {
   return false;
 }
 
-_returnable_entry
+_returnable_entry basic_partition_map::get_all(
-basic_partition_map::get_all(const std::string_view name) const {
+    const std::string_view name) const {
   if (const int pos = _index_of(name); name == _data[pos].name)
     return _returnable_entry{_data[pos].props.size, _data[pos].props.isLogical};
 
@@ -194,8 +195,8 @@ void basic_partition_map::clear() {
   _data = new _entry[_capacity];
 }
 
-basic_partition_map &
+basic_partition_map& basic_partition_map::operator=(
-basic_partition_map::operator=(const basic_partition_map &map) {
+    const basic_partition_map& map) {
   if (this != &map) {
     delete[] _data;
 
@@ -217,7 +218,8 @@ bool basic_partition_map::operator==(const basic_partition_map &other) const {
         _data[i].props.size == other._data[i].props.size &&
         _data[i].props.isLogical == other._data[i].props.isLogical)
       continue;
-    else return false;
+    else
+      return false;
 
   return true;
 }

srclib/libpartition_map/tests/test.cpp

@@ -14,10 +14,11 @@
    limitations under the License.
 */
 
+#include <unistd.h>
+
 #include <fstream>
 #include <iostream>
 #include <libpartition_map/lib.hpp>
-#include <unistd.h>
 
 int main() {
   if (getuid() != 0) return 2;