run make pretty

test/src/unit-noexcept.cpp

@@ -11,8 +11,8 @@ enum test
 struct pod {};
 struct pod_bis {};
 
-void to_json(json &, pod) noexcept;
-void to_json(json &, pod_bis);
+void to_json(json&, pod) noexcept;
+void to_json(json&, pod_bis);
 void from_json(const json&, pod) noexcept;
 void from_json(const json&, pod_bis);
 static json j;

test/src/unit-regression.cpp

@@ -63,7 +63,7 @@ TEST_CASE("regression tests")
 
     SECTION("pull request #71 - handle enum type")
     {
-        enum { t = 0 , u = 1};
+        enum { t = 0, u = 1};
         json j = json::array();
         j.push_back(t);
 

test/src/unit-udt.cpp

@@ -114,22 +114,22 @@ void to_json(Json& j, country c)
 }
 
 template <typename Json>
-void to_json(Json& j, const person & p)
+void to_json(Json& j, const person& p)
 {
     j = Json{{"age", p.m_age}, {"name", p.m_name}, {"country", p.m_country}};
 }
 
-void to_json(nlohmann::json& j, const address & a)
+void to_json(nlohmann::json& j, const address& a)
 {
     j = a.m_val;
 }
 
-void to_json(nlohmann::json& j, const contact & c)
+void to_json(nlohmann::json& j, const contact& c)
 {
     j = json{{"person", c.m_person}, {"address", c.m_address}};
 }
 
-void to_json(nlohmann::json& j, const contact_book & cb)
+void to_json(nlohmann::json& j, const contact_book& cb)
 {
     j = json{{"name", cb.m_book_name}, {"contacts", cb.m_contacts}};
 }
@@ -140,28 +140,28 @@ bool operator==(age lhs, age rhs)
     return lhs.m_val == rhs.m_val;
 }
 
-bool operator==(const address & lhs, const address & rhs)
+bool operator==(const address& lhs, const address& rhs)
 {
     return lhs.m_val == rhs.m_val;
 }
 
-bool operator==(const name & lhs, const name & rhs)
+bool operator==(const name& lhs, const name& rhs)
 {
     return lhs.m_val == rhs.m_val;
 }
 
-bool operator==(const person & lhs, const person & rhs)
+bool operator==(const person& lhs, const person& rhs)
 {
     return std::tie(lhs.m_name, lhs.m_age) == std::tie(rhs.m_name, rhs.m_age);
 }
 
-bool operator==(const contact & lhs, const contact & rhs)
+bool operator==(const contact& lhs, const contact& rhs)
 {
     return std::tie(lhs.m_person, lhs.m_address) ==
            std::tie(rhs.m_person, rhs.m_address);
 }
 
-bool operator==(const contact_book & lhs, const contact_book & rhs)
+bool operator==(const contact_book& lhs, const contact_book& rhs)
 {
     return std::tie(lhs.m_book_name, lhs.m_contacts) ==
            std::tie(rhs.m_book_name, rhs.m_contacts);
@@ -172,19 +172,19 @@ bool operator==(const contact_book & lhs, const contact_book & rhs)
 namespace udt
 {
 template <typename Json>
-void from_json(const Json & j, age& a)
+void from_json(const Json& j, age& a)
 {
     a.m_val = j.template get<int>();
 }
 
 template <typename Json>
-void from_json(const Json & j, name& n)
+void from_json(const Json& j, name& n)
 {
     n.m_val = j.template get<std::string>();
 }
 
 template <typename Json>
-void from_json(const Json & j, country& c)
+void from_json(const Json& j, country& c)
 {
     const auto str = j.template get<std::string>();
     static const std::map<std::string, country> m =
@@ -200,25 +200,25 @@ void from_json(const Json & j, country& c)
 }
 
 template <typename Json>
-void from_json(const Json & j, person& p)
+void from_json(const Json& j, person& p)
 {
     p.m_age = j["age"].template get<age>();
     p.m_name = j["name"].template get<name>();
     p.m_country = j["country"].template get<country>();
 }
 
-void from_json(const nlohmann::json & j, address& a)
+void from_json(const nlohmann::json& j, address& a)
 {
     a.m_val = j.get<std::string>();
 }
 
-void from_json(const nlohmann::json & j, contact& c)
+void from_json(const nlohmann::json& j, contact& c)
 {
     c.m_person = j["person"].get<person>();
     c.m_address = j["address"].get<address>();
 }
 
-void from_json(const nlohmann::json & j, contact_book& cb)
+void from_json(const nlohmann::json& j, contact_book& cb)
 {
     cb.m_book_name = j["name"].get<name>();
     cb.m_contacts = j["contacts"].get<std::vector<contact>>();
@@ -297,7 +297,7 @@ namespace nlohmann
 template <typename T>
 struct adl_serializer<std::shared_ptr<T>>
 {
-    static void to_json(json& j, const std::shared_ptr<T> & opt)
+    static void to_json(json& j, const std::shared_ptr<T>& opt)
     {
         if (opt)
         {
@@ -309,7 +309,7 @@ struct adl_serializer<std::shared_ptr<T>>
         }
     }
 
-    static void from_json(const json & j, std::shared_ptr<T>& opt)
+    static void from_json(const json& j, std::shared_ptr<T>& opt)
     {
         if (j.is_null())
         {
@@ -325,12 +325,12 @@ struct adl_serializer<std::shared_ptr<T>>
 template <>
 struct adl_serializer<udt::legacy_type>
 {
-    static void to_json(json& j, const udt::legacy_type & l)
+    static void to_json(json& j, const udt::legacy_type& l)
     {
         j = std::stoi(l.number);
     }
 
-    static void from_json(const json & j, udt::legacy_type& l)
+    static void from_json(const json& j, udt::legacy_type& l)
     {
         l.number = std::to_string(j.get<int>());
     }
@@ -395,18 +395,18 @@ template <>
 struct adl_serializer<std::vector<float>>
 {
     using type = std::vector<float>;
-    static void to_json(json& j, const type &)
+    static void to_json(json& j, const type&)
     {
         j = "hijacked!";
     }
 
-    static void from_json(const json &, type& opt)
+    static void from_json(const json&, type& opt)
     {
         opt = {42.0, 42.0, 42.0};
     }
 
     // preferred version
-    static type from_json(const json &)
+    static type from_json(const json&)
     {
         return {4.0, 5.0, 6.0};
     }
@@ -419,7 +419,7 @@ TEST_CASE("even supported types can be specialized", "[udt]")
     CHECK(j.dump() == R"("hijacked!")");
     auto f = j.get<std::vector<float>>();
     // the single argument from_json method is preferred
-    CHECK((f == std::vector<float>{4.0, 5.0, 6.0}));
+    CHECK((f == std::vector<float> {4.0, 5.0, 6.0}));
 }
 
 namespace nlohmann
@@ -427,7 +427,7 @@ namespace nlohmann
 template <typename T>
 struct adl_serializer<std::unique_ptr<T>>
 {
-    static void to_json(json& j, const std::unique_ptr<T> & opt)
+    static void to_json(json& j, const std::unique_ptr<T>& opt)
     {
         if (opt)
         {
@@ -440,7 +440,7 @@ struct adl_serializer<std::unique_ptr<T>>
     }
 
     // this is the overload needed for non-copyable types,
-    static std::unique_ptr<T> from_json(const json & j)
+    static std::unique_ptr<T> from_json(const json& j)
     {
         if (j.is_null())
         {
@@ -494,9 +494,9 @@ struct pod_serializer
     // use adl for non-pods, or scalar types
     template <
         typename Json, typename U = T,
-      typename std::enable_if<
-          not(std::is_pod<U>::value and std::is_class<U>::value), int>::type = 0>
-  static void from_json(const Json &j, U &t)
+        typename std::enable_if <
+            not(std::is_pod<U>::value and std::is_class<U>::value), int >::type = 0 >
+    static void from_json(const Json& j, U& t)
     {
         using nlohmann::from_json;
         from_json(j, t);
@@ -506,7 +506,7 @@ struct pod_serializer
     template <typename Json, typename U = T,
               typename std::enable_if<
                   std::is_pod<U>::value and std::is_class<U>::value, int>::type = 0>
-  static void from_json(const  Json &j, U &t)
+    static void from_json(const  Json& j, U& t)
     {
         std::uint64_t value;
         // TODO The following block is no longer relevant in this serializer, make another one that shows the issue
@@ -524,15 +524,15 @@ struct pod_serializer
         // calling get calls from_json, for now, we cannot do this in custom
         // serializers
         nlohmann::from_json(j, value);
-    auto bytes = static_cast<char *>(static_cast<void *>(&value));
+        auto bytes = static_cast<char*>(static_cast<void*>(&value));
         std::memcpy(&t, bytes, sizeof(value));
     }
 
     template <
         typename Json, typename U = T,
-      typename std::enable_if<
-          not(std::is_pod<U>::value and std::is_class<U>::value), int>::type = 0>
-  static void to_json(Json &j, const  T &t)
+        typename std::enable_if <
+            not(std::is_pod<U>::value and std::is_class<U>::value), int >::type = 0 >
+    static void to_json(Json& j, const  T& t)
     {
         using nlohmann::to_json;
         to_json(j, t);
@@ -541,9 +541,9 @@ struct pod_serializer
     template <typename Json, typename U = T,
               typename std::enable_if<
                   std::is_pod<U>::value and std::is_class<U>::value, int>::type = 0>
-  static void to_json(Json &j, const  T &t) noexcept
+    static void to_json(Json& j, const  T& t) noexcept
     {
-    auto bytes = static_cast< const unsigned char*>(static_cast<const void *>(&t));
+        auto bytes = static_cast< const unsigned char*>(static_cast<const void*>(&t));
         std::uint64_t value = bytes[0];
         for (auto i = 1; i < 8; ++i)
             value |= std::uint64_t{bytes[i]} << 8 * i;
@@ -566,13 +566,13 @@ struct non_pod
 };
 
 template <typename Json>
-void to_json(Json& j, const non_pod & np)
+void to_json(Json& j, const non_pod& np)
 {
     j = np.s;
 }
 
 template <typename Json>
-void from_json(const Json & j, non_pod& np)
+void from_json(const Json& j, non_pod& np)
 {
     np.s = j.template get<std::string>();
 }
@@ -583,7 +583,7 @@ bool operator==(small_pod lhs, small_pod rhs) noexcept
            std::tie(rhs.begin, rhs.middle, rhs.end);
 }
 
-bool operator==(const  non_pod &lhs, const  non_pod &rhs) noexcept
+bool operator==(const  non_pod& lhs, const  non_pod& rhs) noexcept
 {
     return lhs.s == rhs.s;
 }
@@ -622,13 +622,13 @@ using custom_json = nlohmann::basic_json<std::map, std::vector, std::string, boo
 template <typename T, typename>
 struct another_adl_serializer
 {
-    static void from_json(const custom_json & j , T& t)
+    static void from_json(const custom_json& j, T& t)
     {
         using nlohmann::from_json;
         from_json(j, t);
     }
 
-    static void to_json(custom_json& j , const T & t)
+    static void to_json(custom_json& j, const T& t)
     {
         using nlohmann::to_json;
         to_json(j, t);