Batch clang format files with script.

Author: XuhuaHuang

AbstractDataType/queue.h

@@ -1,15 +1,15 @@
 /**
  * @brief Contains declaration of a commonly-seen data structure queue implemented in C.
- * 
+ *
  */
 
 #ifndef QUEUE_H
 #define QUEUE_H
 
+#include <limits.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <limits.h>
 
 #define QUEUE_EMPTY INT_MIN
 
@@ -24,10 +24,10 @@ typedef struct _queue queue;
 // the compiler knows what to do with a pointer (an address)
 // so long as it is NOT de-referenced
 queue* q_create(int max_size);
-void q_destroy(queue *q);
-bool q_empty(queue *q);
-bool q_full(queue *q);
-bool q_endqueue(queue *q, int value);
-int q_dequeue(queue *q);
+void   q_destroy(queue* q);
+bool   q_empty(queue* q);
+bool   q_full(queue* q);
+bool   q_endqueue(queue* q, int value);
+int    q_dequeue(queue* q);
 
 #endif

Array/array_size.hpp

@@ -1,14 +1,14 @@
 #pragma once
 
-template<typename T, auto N>
-[[nodiscard]] consteval auto array_size(T (&)[N])
-{
+template <typename T, auto N>
+[[nodiscard]]
+consteval auto array_size(T (&)[N]) {
     return N;
 }
 
-template<typename T>
+template <typename T>
     requires requires { std::declval<T>().size(); }
-[[nodiscard]] constexpr auto array_size(T&& t)
-{
+[[nodiscard]]
+constexpr auto array_size(T&& t) {
     return t.size();
 }

Array/iterable_array.cpp

@@ -7,110 +7,88 @@
 #include <utility>
 #include <vector>
 
-template<typename T>
+template <typename T>
 concept is_iterable = requires (T array_like) {
-    {
-        array_like.has_next()
-    } -> std::convertible_to<bool>;
-    {
-        array_like.next()
-    } -> std::same_as<uint32_t>;
-    {
-        array_like.reset()
-    };
+    { array_like.has_next() } -> std::convertible_to<bool>;
+    { array_like.next() } -> std::same_as<uint32_t>;
+    { array_like.reset() };
 };
 
-template<is_iterable T>
-constexpr std::size_t count(T array)
-{
+template <is_iterable T>
+constexpr std::size_t count(T array) {
     array.reset();
     std::size_t count = 0;
-    while (array.has_next())
-    {
+    while (array.has_next()) {
         array.next();
         count++;
     }
     return count;
 }
 
-template<typename T>
-constexpr std::size_t count(T&& array)
-{
+template <typename T>
+constexpr std::size_t count(T&& array) {
     return count(array);
 }
 
-struct iterable_array
-{
-    inline constexpr iterable_array() noexcept                      = default;
-    inline constexpr iterable_array(const iterable_array&) noexcept = default;
-    inline constexpr iterable_array(const std::size_t s)
-        : array(s)
-    {
-    }
-    inline constexpr ~iterable_array() noexcept = default;
+struct iterable_array {
+    constexpr inline iterable_array() noexcept                      = default;
+    constexpr inline iterable_array(const iterable_array&) noexcept = default;
+    constexpr inline iterable_array(const std::size_t s)
+        : array(s) {}
+    constexpr inline ~iterable_array() noexcept = default;
 
     std::vector<uint32_t> array{};
     std::size_t           index = 0;
 
-    inline constexpr void          reset() { index = 0; }
-    inline constexpr bool          has_next() const noexcept { return index < array.size(); }
-    inline constexpr std::uint32_t next()
-    {
+    constexpr inline void          reset() { index = 0; }
+    constexpr inline bool          has_next() const noexcept { return index < array.size(); }
+    constexpr inline std::uint32_t next() {
         index++;
         return array[index - 1];
     }
 };
 
-consteval [[nodiscard]] std::size_t __cdecl count_iterable_array()
-{
+consteval [[nodiscard]] std::size_t __cdecl count_iterable_array() {
     static_assert(std::is_constant_evaluated());
     return count(iterable_array(10));
 }
 
-namespace std
-{
+namespace std {
 
-template<>
-struct tuple_size<iterable_array> : integral_constant<std::size_t, 2>
-{
-};
+template <>
+struct tuple_size<iterable_array> : integral_constant<std::size_t, 2> {};
 
-template<>
-struct tuple_element<0U, iterable_array>
-{
+template <>
+struct tuple_element<0U, iterable_array> {
     using type = vector<uint32_t>;
 };
 
-template<>
-struct tuple_element<1U, iterable_array>
-{
+template <>
+struct tuple_element<1U, iterable_array> {
     using type = size_t;
 };
 
-template<size_t I>
+template <size_t I>
     requires (I < tuple_size<iterable_array>::value)
-typename tuple_element<I, iterable_array>::type& get(iterable_array& itrarray)
-{
+typename tuple_element<I, iterable_array>::type& get(iterable_array& itrarray) {
     if constexpr (I == 0)
         return itrarray.array;
     else /* constexpr */
         return itrarray.index;
 }
 
-template<size_t I>
+template <size_t I>
     requires (I < tuple_size<iterable_array>::value)
-typename const tuple_element<I, iterable_array>::type& get(const iterable_array& itrarray)
-{
+typename const tuple_element<I, iterable_array>::type& get(const iterable_array& itrarray) {
     if constexpr (I == 0)
         return itrarray.array;
     else /* constexpr */
         return itrarray.index;
 }
 
-template<size_t I>
+template <size_t I>
     requires (I < tuple_size<iterable_array>::value)
-typename tuple_element<I, iterable_array>::type&& get(iterable_array&& itrarray)
-{
+typename tuple_element<I, iterable_array>::type&& get(iterable_array&& itrarray) {
     if constexpr (I == 0)
         return std::forward<tuple_element<0U, iterable_array>::type>(itrarray.array);
     else /* constexpr */
@@ -119,8 +97,7 @@ typename tuple_element<I, iterable_array>::type&& get(iterable_array&& itrarray)
 
 } // namespace std
 
-auto main(void) -> int
-{
+int main(void) {
     static_assert(std::tuple_size<iterable_array>::value == 2);
     static_assert(std::tuple_size_v<iterable_array> == 2);
     static_assert(std::is_same_v<std::tuple_element<0, iterable_array>::type, std::vector<std::uint32_t>>);

Array/std_array_get_impl.inl

@@ -1,40 +1,29 @@
-namespace std _GLIBCXX_VISIBILITY(default)
-{
+namespace std _GLIBCXX_VISIBILITY(default) {
 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
 
-  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-    constexpr _Tp&
-    get(array<_Tp, _Nm>& __arr) noexcept
-    {
-      static_assert(_Int < _Nm, "array index is within bounds");
-      return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::
-    _S_ref(__arr._M_elems, _Int);
-    }
+template <std::size_t _Int, typename _Tp, std::size_t _Nm>
+constexpr _Tp& get(array<_Tp, _Nm>& __arr) noexcept {
+    static_assert(_Int < _Nm, "array index is within bounds");
+    return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::_S_ref(__arr._M_elems, _Int);
+}
 
-  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-    constexpr _Tp&&
-    get(array<_Tp, _Nm>&& __arr) noexcept
-    {
-      static_assert(_Int < _Nm, "array index is within bounds");
-      return std::move(_GLIBCXX_STD_C::get<_Int>(__arr));
-    }
+template <std::size_t _Int, typename _Tp, std::size_t _Nm>
+constexpr _Tp&& get(array<_Tp, _Nm>&& __arr) noexcept {
+    static_assert(_Int < _Nm, "array index is within bounds");
+    return std::move(_GLIBCXX_STD_C::get<_Int>(__arr));
+}
 
-  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-    constexpr const _Tp&
-    get(const array<_Tp, _Nm>& __arr) noexcept
-    {
-      static_assert(_Int < _Nm, "array index is within bounds");
-      return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::
-    _S_ref(__arr._M_elems, _Int);
-    }
+template <std::size_t _Int, typename _Tp, std::size_t _Nm>
+constexpr const _Tp& get(const array<_Tp, _Nm>& __arr) noexcept {
+    static_assert(_Int < _Nm, "array index is within bounds");
+    return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::_S_ref(__arr._M_elems, _Int);
+}
 
-  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-    constexpr const _Tp&&
-    get(const array<_Tp, _Nm>&& __arr) noexcept
-    {
-      static_assert(_Int < _Nm, "array index is within bounds");
-      return std::move(_GLIBCXX_STD_C::get<_Int>(__arr));
-    }
+template <std::size_t _Int, typename _Tp, std::size_t _Nm>
+constexpr const _Tp&& get(const array<_Tp, _Nm>&& __arr) noexcept {
+    static_assert(_Int < _Nm, "array index is within bounds");
+    return std::move(_GLIBCXX_STD_C::get<_Int>(__arr));
+}
 
 _GLIBCXX_END_NAMESPACE_CONTAINER
-} // namespace std
+} // namespace std _GLIBCXX_VISIBILITY(default)

BitwiseOperator/bitwise_operator.cpp

@@ -8,13 +8,11 @@
 
 #include <iostream>
 
-void print(const int value)
-{
+void print(const int value) {
     std::cout << value << "\n";
 }
 
-int main(void)
-{
+int main(void) {
     unsigned int a = 5;
     // Debug -> Windows -> Memory -> Memory1
     // OR Ctrl + Alt+ M, 1

Boost/LambdaExample/lambda.cpp

@@ -17,18 +17,16 @@
  * \date   September 2022
  *********************************************************************/
 
+#include <algorithm>
 #include <boost/lambda/lambda.hpp>
 #include <iostream>
 #include <iterator>
-#include <algorithm>
 
-auto main(void) -> int {
+int main(void) {
     using namespace boost::lambda;
     typedef std::istream_iterator<int> in;
 
-    std::for_each(
-        in(std::cin), in(), std::cout << (_1 * 3) << " "
-    );
+    std::for_each(in(std::cin), in(), std::cout << (_1 * 3) << " ");
 
     return EXIT_SUCCESS;
 }

Boost/MultiArray/multi_array.cpp

@@ -12,12 +12,11 @@
 #include <boost/multi_array.hpp>
 #include <iostream>
 
-int main()
-{
+int main() {
     // define the shape of the tensor (3D)
-    const int d1   = 2;
-    const int d2   = 3;
-    const int d3   = 4;
+    const int d1 = 2;
+    const int d2 = 3;
+    const int d3 = 4;
 
     // create the tensor
     // 3 dimensional array
@@ -27,24 +26,18 @@ int main()
     tensor_t tensor(boost::extents[d1][d2][d3]);
 
     // fill the tensor with some values
-    for (int i = 0; i < d1; ++i)
-    {
-        for (int j = 0; j < d2; ++j)
-        {
-            for (int k = 0; k < d3; ++k)
-            {
+    for (int i = 0; i < d1; ++i) {
+        for (int j = 0; j < d2; ++j) {
+            for (int k = 0; k < d3; ++k) {
                 tensor[i][j][k] = i * j * k;
             }
         }
     }
 
     // print the tensor
-    for (int i = 0; i < d1; ++i)
-    {
-        for (int j = 0; j < d2; ++j)
-        {
-            for (int k = 0; k < d3; ++k)
-            {
+    for (int i = 0; i < d1; ++i) {
+        for (int j = 0; j < d2; ++j) {
+            for (int k = 0; k < d3; ++k) {
                 std::cout << tensor[i][j][k] << " ";
             }
             std::cout << "\n";

Boost/StringRef/string_ref.cpp

@@ -7,15 +7,15 @@
  * \date   December 07, 2022
  *********************************************************************/
 
-#include <iostream>
 #include <stdlib.h>
-#include <string>
-#include <cassert>
-#include <boost/utility/string_ref.hpp>
 
-auto main(void) -> int {
+#include <boost/utility/string_ref.hpp>
+#include <cassert>
+#include <iostream>
+#include <string>
 
-    const char* c_str = { "Days of Future Past" };
+int main(void) {
+    const char* c_str = {"Days of Future Past"};
     std::string cpp_str(c_str);
 
     boost::string_ref c_str_ref(c_str);
@@ -27,7 +27,7 @@ auto main(void) -> int {
 
     boost::string_ref first_4_chars(c_str, 4); // "Days"
     // note: boost::string_ref also supports substr()
-    assert(cpp_str_ref.front()  == 'D');
+    assert(cpp_str_ref.front() == 'D');
     assert(first_4_chars == cpp_str.substr(0, 4));
 
     auto first_five_chars = [](boost::string_ref str_ref) -> boost::string_ref {