tidy code

danielaparker · danielaparker · commit 956683e69179 · 2024-12-30T18:16:40.000-05:00
diff --git a/include/jsoncons/detail/grisu3.hpp b/include/jsoncons/detail/grisu3.hpp
@@ -42,8 +42,6 @@ minor modifications.
 #include <cstring> // std::memmove
 #include <stdlib.h>
 
-#include <jsoncons/detail/write_number.hpp>
-
 namespace jsoncons { namespace detail {
 
 // diy_fp
diff --git a/include/jsoncons_ext/bson/decode_bson.hpp b/include/jsoncons_ext/bson/decode_bson.hpp
@@ -197,7 +197,7 @@ namespace bson {
         return val;
     }
   
-} // bson
+} // namespace bson
 } // namespace jsoncons
 
 #endif // JSONCONS_EXT_BSON_DECODE_BSON_HPP
diff --git a/include/jsoncons_ext/bson/encode_bson.hpp b/include/jsoncons_ext/bson/encode_bson.hpp
@@ -139,7 +139,7 @@ namespace bson {
         }
     }
       
-} // bson
+} // namespace bson
 } // namespace jsoncons
 
 #endif // JSONCONS_EXT_BSON_DECODE_BSON_HPP
diff --git a/include/jsoncons_ext/csv/csv_options.hpp b/include/jsoncons_ext/csv/csv_options.hpp
@@ -257,7 +257,7 @@ void parse_column_types(const std::basic_string<CharT>& types,
     }
 }
 
-} // detail
+} // namespace detail
 
 template <typename CharT>
 class basic_csv_options;
diff --git a/include/jsoncons_ext/jsonpatch/jsonpatch_error.hpp b/include/jsoncons_ext/jsonpatch/jsonpatch_error.hpp
@@ -71,7 +71,7 @@ namespace jsoncons { namespace jsonpatch {
         return std::error_code(static_cast<int>(result),jsonpatch_error_category());
     }
 
-} // jsonpatch
+} // namespace jsonpatch
 } // namespace jsoncons
 
 namespace std {
@@ -117,7 +117,7 @@ namespace jsoncons { namespace jsonpatch {
         }
     };
     
-} // jsonpatch
+} // namespace jsonpatch
 } // namespace jsoncons
 
 #endif // JSONCONS_EXT_JSONPATCH_JSONPATCH_ERROR_HPP
diff --git a/include/jsoncons_ext/jsonpath/expression.hpp b/include/jsoncons_ext/jsonpath/expression.hpp
@@ -481,14 +481,11 @@ namespace detail {
             {
                 return Json(-val.template as<int64_t>(), semantic_tag::none);
             }
-            else if (val.is_double())
+            if (val.is_double())
             {
                 return Json(-val.as_double(), semantic_tag::none);
             }
-            else
-            {
-                return Json::null();
-            }
+            return Json::null();
         }
     };
 
@@ -546,9 +543,6 @@ namespace detail {
         {
             return "binary operator";
         }
-
-    protected:
-        ~binary_operator() = default;
     };
 
     // Implementations
@@ -609,10 +603,7 @@ namespace detail {
             {
                 return rhs;
             }
-            else
-            {
-                return lhs;
-            }
+            return lhs;
         }
 
         std::string to_string(int level) const override
@@ -703,7 +694,7 @@ namespace detail {
             {
                 return lhs < rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);
             }
-            else if (lhs.is_string() && rhs.is_string())
+            if (lhs.is_string() && rhs.is_string())
             {
                 return lhs < rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);
             }
@@ -740,7 +731,7 @@ namespace detail {
             {
                 return lhs <= rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);
             }
-            else if (lhs.is_string() && rhs.is_string())
+            if (lhs.is_string() && rhs.is_string())
             {
                 return lhs <= rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);
             }
@@ -779,7 +770,7 @@ namespace detail {
             {
                 return lhs > rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);
             }
-            else if (lhs.is_string() && rhs.is_string())
+            if (lhs.is_string() && rhs.is_string())
             {
                 return lhs > rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);
             }
@@ -816,7 +807,7 @@ namespace detail {
             {
                 return lhs >= rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);
             }
-            else if (lhs.is_string() && rhs.is_string())
+            if (lhs.is_string() && rhs.is_string())
             {
                 return lhs >= rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);
             }
@@ -853,18 +844,15 @@ namespace detail {
             {
                 return Json::null();
             }
-            else if (lhs.is_int64() && rhs.is_int64())
+            if (lhs.is_int64() && rhs.is_int64())
             {
                 return Json(((lhs.template as<int64_t>() + rhs.template as<int64_t>())), semantic_tag::none);
             }
-            else if (lhs.is_uint64() && rhs.is_uint64())
+            if (lhs.is_uint64() && rhs.is_uint64())
             {
                 return Json((lhs.template as<uint64_t>() + rhs.template as<uint64_t>()), semantic_tag::none);
             }
-            else
-            {
-                return Json((lhs.as_double() + rhs.as_double()), semantic_tag::none);
-            }
+            return Json((lhs.as_double() + rhs.as_double()), semantic_tag::none);
         }
 
         std::string to_string(int level) const override
@@ -897,18 +885,15 @@ namespace detail {
             {
                 return Json::null();
             }
-            else if (lhs.is_int64() && rhs.is_int64())
+            if (lhs.is_int64() && rhs.is_int64())
             {
                 return Json(((lhs.template as<int64_t>() - rhs.template as<int64_t>())), semantic_tag::none);
             }
-            else if (lhs.is_uint64() && rhs.is_uint64())
+            if (lhs.is_uint64() && rhs.is_uint64())
             {
                 return Json((lhs.template as<uint64_t>() - rhs.template as<uint64_t>()), semantic_tag::none);
             }
-            else
-            {
-                return Json((lhs.as_double() - rhs.as_double()), semantic_tag::none);
-            }
+            return Json((lhs.as_double() - rhs.as_double()), semantic_tag::none);
         }
 
         std::string to_string(int level) const override
@@ -941,18 +926,15 @@ namespace detail {
             {
                 return Json::null();
             }
-            else if (lhs.is_int64() && rhs.is_int64())
+            if (lhs.is_int64() && rhs.is_int64())
             {
                 return Json(((lhs.template as<int64_t>() * rhs.template as<int64_t>())), semantic_tag::none);
             }
-            else if (lhs.is_uint64() && rhs.is_uint64())
+            if (lhs.is_uint64() && rhs.is_uint64())
             {
                 return Json((lhs.template as<uint64_t>() * rhs.template as<uint64_t>()), semantic_tag::none);
             }
-            else
-            {
-                return Json((lhs.as_double() * rhs.as_double()), semantic_tag::none);
-            }
+            return Json((lhs.as_double() * rhs.as_double()), semantic_tag::none);
         }
 
         std::string to_string(int level) const override
@@ -987,18 +969,15 @@ namespace detail {
             {
                 return Json::null();
             }
-            else if (lhs.is_int64() && rhs.is_int64())
+            if (lhs.is_int64() && rhs.is_int64())
             {
                 return Json(((lhs.template as<int64_t>() / rhs.template as<int64_t>())), semantic_tag::none);
             }
-            else if (lhs.is_uint64() && rhs.is_uint64())
+            if (lhs.is_uint64() && rhs.is_uint64())
             {
                 return Json((lhs.template as<uint64_t>() / rhs.template as<uint64_t>()), semantic_tag::none);
             }
-            else
-            {
-                return Json((lhs.as_double() / rhs.as_double()), semantic_tag::none);
-            }
+            return Json((lhs.as_double() / rhs.as_double()), semantic_tag::none);
         }
 
         std::string to_string(int level) const override
@@ -1033,18 +1012,15 @@ namespace detail {
             {
                 return Json::null();
             }
-            else if (lhs.is_int64() && rhs.is_int64())
+            if (lhs.is_int64() && rhs.is_int64())
             {
                 return Json(((lhs.template as<int64_t>() % rhs.template as<int64_t>())), semantic_tag::none);
             }
-            else if (lhs.is_uint64() && rhs.is_uint64())
+            if (lhs.is_uint64() && rhs.is_uint64())
             {
                 return Json((lhs.template as<uint64_t>() % rhs.template as<uint64_t>()), semantic_tag::none);
             }
-            else
-            {
-                return Json(fmod(lhs.as_double(), rhs.as_double()), semantic_tag::none);
-            }
+            return Json(fmod(lhs.as_double(), rhs.as_double()), semantic_tag::none);
         }
 
         std::string to_string(int level) const override
@@ -1074,8 +1050,14 @@ namespace detail {
         {
         }
 
+        function_base(const function_base&) = default;
+        function_base(function_base&&) = default;
+        
         virtual ~function_base() noexcept = default;
 
+        function_base& operator=(const function_base&) = default;
+        function_base& operator=(function_base&&) = default;
+
         jsoncons::optional<std::size_t> arity() const
         {
             return arg_count_;
@@ -1232,10 +1214,7 @@ namespace detail {
             {
                 return value_type(true, semantic_tag::none);
             }
-            else
-            {
-                return value_type(false, semantic_tag::none);
-            }
+            return value_type(false, semantic_tag::none);
         }
 
         std::string to_string(int level) const override
@@ -1294,10 +1273,7 @@ namespace detail {
             {
                 return value_type(true, semantic_tag::none);
             }
-            else
-            {
-                return value_type(false, semantic_tag::none);
-            }
+            return value_type(false, semantic_tag::none);
         }
 
         std::string to_string(int level) const override
@@ -1590,7 +1566,7 @@ namespace detail {
                     {
                         return value_type(sn, semantic_tag::none);
                     }
-                    jsoncons::detail::chars_to to_double;
+                    jsoncons::detail::chars_to to_double{};
                     try
                     {
                         auto s = arg0.as_string();
@@ -2405,7 +2381,7 @@ namespace detail {
         {
         }
 
-        virtual std::string to_string(int = 0) const
+        virtual std::string to_string(int) const
         {
             return std::string();
         }
@@ -2528,15 +2504,9 @@ namespace detail {
                     ec = jsonpath_errc::unknown_function;
                     return nullptr;
                 }
-                else
-                {
-                    return it2->second.get();
-                }
-            }
-            else
-            {
-                return it->second.get();
+                return it2->second.get();
             }
+            return it->second.get();
         }
 
         const unary_operator<Json>* get_unary_not() const
diff --git a/include/jsoncons_ext/jsonpath/jsonpath_error.hpp b/include/jsoncons_ext/jsonpath/jsonpath_error.hpp
@@ -164,7 +164,7 @@ namespace jsoncons { namespace jsonpath {
         return std::error_code(static_cast<int>(result),jsonpath_error_category());
     }
 
-} // jsonpath
+} // namespace jsonpath
 } // namespace jsoncons
 
 namespace std {
diff --git a/include/jsoncons_ext/msgpack/decode_msgpack.hpp b/include/jsoncons_ext/msgpack/decode_msgpack.hpp
@@ -198,7 +198,7 @@ namespace msgpack {
         return val;
     }
 
-} // msgpack
+} // namespace msgpack
 } // namespace jsoncons
 
 #endif // JSONCONS_EXT_MSGPACK_DECODE_MSGPACK_HPP
diff --git a/include/jsoncons_ext/msgpack/encode_msgpack.hpp b/include/jsoncons_ext/msgpack/encode_msgpack.hpp
@@ -137,7 +137,7 @@ namespace msgpack {
         }
     }
 
-} // msgpack
+} // namespace msgpack
 } // namespace jsoncons
 
 #endif // JSONCONS_EXT_MSGPACK_ENCODE_MSGPACK_HPP
diff --git a/include/jsoncons_ext/ubjson/decode_ubjson.hpp b/include/jsoncons_ext/ubjson/decode_ubjson.hpp
@@ -197,7 +197,7 @@ namespace ubjson {
         return val;
     }
 
-} // ubjson
+} // namespace ubjson
 } // namespace jsoncons
 
 #endif // JSONCONS_EXT_UBJSON_DECODE_UBJSON_HPP
diff --git a/include/jsoncons_ext/ubjson/encode_ubjson.hpp b/include/jsoncons_ext/ubjson/encode_ubjson.hpp
@@ -137,7 +137,7 @@ namespace ubjson {
         }
     }
 
-} // ubjson
+} // namespace ubjson
 } // namespace jsoncons
 
 #endif // JSONCONS_EXT_UBJSON_ENCODE_UBJSON_HPP

Original file line number	Diff line number	Diff line change
`@@ -197,7 +197,7 @@ namespace bson {`
`197`	`197`	`return val;`
`198`	`198`	`}`
`199`	`199`
`200`		`-} // bson`
	`200`	`+} // namespace bson`
`201`	`201`	`} // namespace jsoncons`
`202`	`202`
`203`	`203`	`#endif // JSONCONS_EXT_BSON_DECODE_BSON_HPP`
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ namespace bson {`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`
`142`		`-} // bson`
	`142`	`+} // namespace bson`
`143`	`143`	`} // namespace jsoncons`
`144`	`144`
`145`	`145`	`#endif // JSONCONS_EXT_BSON_DECODE_BSON_HPP`
Original file line number	Diff line number	Diff line change
`@@ -257,7 +257,7 @@ void parse_column_types(const std::basic_string<CharT>& types,`
`257`	`257`	`}`
`258`	`258`	`}`
`259`	`259`
`260`		`-} // detail`
	`260`	`+} // namespace detail`
`261`	`261`
`262`	`262`	`template <typename CharT>`
`263`	`263`	`class basic_csv_options;`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ namespace jsoncons { namespace jsonpatch {`
`71`	`71`	`return std::error_code(static_cast<int>(result),jsonpatch_error_category());`
`72`	`72`	`}`
`73`	`73`
`74`		`-} // jsonpatch`
	`74`	`+} // namespace jsonpatch`
`75`	`75`	`} // namespace jsoncons`
`76`	`76`
`77`	`77`	`namespace std {`
`@@ -117,7 +117,7 @@ namespace jsoncons { namespace jsonpatch {`
`117`	`117`	`}`
`118`	`118`	`};`
`119`	`119`
`120`		`-} // jsonpatch`
	`120`	`+} // namespace jsonpatch`
`121`	`121`	`} // namespace jsoncons`
`122`	`122`
`123`	`123`	`#endif // JSONCONS_EXT_JSONPATCH_JSONPATCH_ERROR_HPP`
Original file line number	Diff line number	Diff line change
`@@ -481,14 +481,11 @@ namespace detail {`
`481`	`481`	`{`
`482`	`482`	`return Json(-val.template as<int64_t>(), semantic_tag::none);`
`483`	`483`	`}`
`484`		`- else if (val.is_double())`
	`484`	`+ if (val.is_double())`
`485`	`485`	`{`
`486`	`486`	`return Json(-val.as_double(), semantic_tag::none);`
`487`	`487`	`}`
`488`		`- else`
`489`		`- {`
`490`		`- return Json::null();`
`491`		`- }`
	`488`	`+ return Json::null();`
`492`	`489`	`}`
`493`	`490`	`};`
`494`	`491`
`@@ -546,9 +543,6 @@ namespace detail {`
`546`	`543`	`{`
`547`	`544`	`return "binary operator";`
`548`	`545`	`}`
`549`		`-`
`550`		`- protected:`
`551`		`- ~binary_operator() = default;`
`552`	`546`	`};`
`553`	`547`
`554`	`548`	`// Implementations`
`@@ -609,10 +603,7 @@ namespace detail {`
`609`	`603`	`{`
`610`	`604`	`return rhs;`
`611`	`605`	`}`
`612`		`- else`
`613`		`- {`
`614`		`- return lhs;`
`615`		`- }`
	`606`	`+ return lhs;`
`616`	`607`	`}`
`617`	`608`
`618`	`609`	`std::string to_string(int level) const override`
`@@ -703,7 +694,7 @@ namespace detail {`
`703`	`694`	`{`
`704`	`695`	`return lhs < rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);`
`705`	`696`	`}`
`706`		`- else if (lhs.is_string() && rhs.is_string())`
	`697`	`+ if (lhs.is_string() && rhs.is_string())`
`707`	`698`	`{`
`708`	`699`	`return lhs < rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);`
`709`	`700`	`}`
`@@ -740,7 +731,7 @@ namespace detail {`
`740`	`731`	`{`
`741`	`732`	`return lhs <= rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);`
`742`	`733`	`}`
`743`		`- else if (lhs.is_string() && rhs.is_string())`
	`734`	`+ if (lhs.is_string() && rhs.is_string())`
`744`	`735`	`{`
`745`	`736`	`return lhs <= rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);`
`746`	`737`	`}`
`@@ -779,7 +770,7 @@ namespace detail {`
`779`	`770`	`{`
`780`	`771`	`return lhs > rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);`
`781`	`772`	`}`
`782`		`- else if (lhs.is_string() && rhs.is_string())`
	`773`	`+ if (lhs.is_string() && rhs.is_string())`
`783`	`774`	`{`
`784`	`775`	`return lhs > rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);`
`785`	`776`	`}`
`@@ -816,7 +807,7 @@ namespace detail {`
`816`	`807`	`{`
`817`	`808`	`return lhs >= rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);`
`818`	`809`	`}`
`819`		`- else if (lhs.is_string() && rhs.is_string())`
	`810`	`+ if (lhs.is_string() && rhs.is_string())`
`820`	`811`	`{`
`821`	`812`	`return lhs >= rhs ? Json(true, semantic_tag::none) : Json(false, semantic_tag::none);`
`822`	`813`	`}`
`@@ -853,18 +844,15 @@ namespace detail {`
`853`	`844`	`{`
`854`	`845`	`return Json::null();`
`855`	`846`	`}`
`856`		`- else if (lhs.is_int64() && rhs.is_int64())`
	`847`	`+ if (lhs.is_int64() && rhs.is_int64())`
`857`	`848`	`{`
`858`	`849`	`return Json(((lhs.template as<int64_t>() + rhs.template as<int64_t>())), semantic_tag::none);`
`859`	`850`	`}`
`860`		`- else if (lhs.is_uint64() && rhs.is_uint64())`
	`851`	`+ if (lhs.is_uint64() && rhs.is_uint64())`
`861`	`852`	`{`
`862`	`853`	`return Json((lhs.template as<uint64_t>() + rhs.template as<uint64_t>()), semantic_tag::none);`
`863`	`854`	`}`
`864`		`- else`
`865`		`- {`
`866`		`- return Json((lhs.as_double() + rhs.as_double()), semantic_tag::none);`
`867`		`- }`
	`855`	`+ return Json((lhs.as_double() + rhs.as_double()), semantic_tag::none);`
`868`	`856`	`}`
`869`	`857`
`870`	`858`	`std::string to_string(int level) const override`
`@@ -897,18 +885,15 @@ namespace detail {`
`897`	`885`	`{`
`898`	`886`	`return Json::null();`
`899`	`887`	`}`
`900`		`- else if (lhs.is_int64() && rhs.is_int64())`
	`888`	`+ if (lhs.is_int64() && rhs.is_int64())`
`901`	`889`	`{`
`902`	`890`	`return Json(((lhs.template as<int64_t>() - rhs.template as<int64_t>())), semantic_tag::none);`
`903`	`891`	`}`
`904`		`- else if (lhs.is_uint64() && rhs.is_uint64())`
	`892`	`+ if (lhs.is_uint64() && rhs.is_uint64())`
`905`	`893`	`{`
`906`	`894`	`return Json((lhs.template as<uint64_t>() - rhs.template as<uint64_t>()), semantic_tag::none);`
`907`	`895`	`}`
`908`		`- else`
`909`		`- {`
`910`		`- return Json((lhs.as_double() - rhs.as_double()), semantic_tag::none);`
`911`		`- }`
	`896`	`+ return Json((lhs.as_double() - rhs.as_double()), semantic_tag::none);`
`912`	`897`	`}`
`913`	`898`
`914`	`899`	`std::string to_string(int level) const override`
`@@ -941,18 +926,15 @@ namespace detail {`
`941`	`926`	`{`
`942`	`927`	`return Json::null();`
`943`	`928`	`}`
`944`		`- else if (lhs.is_int64() && rhs.is_int64())`
	`929`	`+ if (lhs.is_int64() && rhs.is_int64())`
`945`	`930`	`{`
`946`	`931`	`return Json(((lhs.template as<int64_t>() * rhs.template as<int64_t>())), semantic_tag::none);`
`947`	`932`	`}`
`948`		`- else if (lhs.is_uint64() && rhs.is_uint64())`
	`933`	`+ if (lhs.is_uint64() && rhs.is_uint64())`
`949`	`934`	`{`
`950`	`935`	`return Json((lhs.template as<uint64_t>() * rhs.template as<uint64_t>()), semantic_tag::none);`
`951`	`936`	`}`
`952`		`- else`
`953`		`- {`
`954`		`- return Json((lhs.as_double() * rhs.as_double()), semantic_tag::none);`
`955`		`- }`
	`937`	`+ return Json((lhs.as_double() * rhs.as_double()), semantic_tag::none);`
`956`	`938`	`}`
`957`	`939`
`958`	`940`	`std::string to_string(int level) const override`
`@@ -987,18 +969,15 @@ namespace detail {`
`987`	`969`	`{`
`988`	`970`	`return Json::null();`
`989`	`971`	`}`
`990`		`- else if (lhs.is_int64() && rhs.is_int64())`
	`972`	`+ if (lhs.is_int64() && rhs.is_int64())`
`991`	`973`	`{`
`992`	`974`	`return Json(((lhs.template as<int64_t>() / rhs.template as<int64_t>())), semantic_tag::none);`
`993`	`975`	`}`
`994`		`- else if (lhs.is_uint64() && rhs.is_uint64())`
	`976`	`+ if (lhs.is_uint64() && rhs.is_uint64())`
`995`	`977`	`{`
`996`	`978`	`return Json((lhs.template as<uint64_t>() / rhs.template as<uint64_t>()), semantic_tag::none);`
`997`	`979`	`}`
`998`		`- else`
`999`		`- {`
`1000`		`- return Json((lhs.as_double() / rhs.as_double()), semantic_tag::none);`
`1001`		`- }`
	`980`	`+ return Json((lhs.as_double() / rhs.as_double()), semantic_tag::none);`
`1002`	`981`	`}`
`1003`	`982`
`1004`	`983`	`std::string to_string(int level) const override`
`@@ -1033,18 +1012,15 @@ namespace detail {`
`1033`	`1012`	`{`
`1034`	`1013`	`return Json::null();`
`1035`	`1014`	`}`
`1036`		`- else if (lhs.is_int64() && rhs.is_int64())`
	`1015`	`+ if (lhs.is_int64() && rhs.is_int64())`
`1037`	`1016`	`{`
`1038`	`1017`	`return Json(((lhs.template as<int64_t>() % rhs.template as<int64_t>())), semantic_tag::none);`
`1039`	`1018`	`}`
`1040`		`- else if (lhs.is_uint64() && rhs.is_uint64())`
	`1019`	`+ if (lhs.is_uint64() && rhs.is_uint64())`
`1041`	`1020`	`{`
`1042`	`1021`	`return Json((lhs.template as<uint64_t>() % rhs.template as<uint64_t>()), semantic_tag::none);`
`1043`	`1022`	`}`
`1044`		`- else`
`1045`		`- {`
`1046`		`- return Json(fmod(lhs.as_double(), rhs.as_double()), semantic_tag::none);`
`1047`		`- }`
	`1023`	`+ return Json(fmod(lhs.as_double(), rhs.as_double()), semantic_tag::none);`
`1048`	`1024`	`}`
`1049`	`1025`
`1050`	`1026`	`std::string to_string(int level) const override`
`@@ -1074,8 +1050,14 @@ namespace detail {`
`1074`	`1050`	`{`
`1075`	`1051`	`}`
`1076`	`1052`
	`1053`	`+ function_base(const function_base&) = default;`
	`1054`	`+ function_base(function_base&&) = default;`
	`1055`	`+`
`1077`	`1056`	`virtual ~function_base() noexcept = default;`
`1078`	`1057`
	`1058`	`+ function_base& operator=(const function_base&) = default;`
	`1059`	`+ function_base& operator=(function_base&&) = default;`
	`1060`	`+`
`1079`	`1061`	`jsoncons::optional<std::size_t> arity() const`
`1080`	`1062`	`{`
`1081`	`1063`	`return arg_count_;`
`@@ -1232,10 +1214,7 @@ namespace detail {`
`1232`	`1214`	`{`
`1233`	`1215`	`return value_type(true, semantic_tag::none);`
`1234`	`1216`	`}`
`1235`		`- else`
`1236`		`- {`
`1237`		`- return value_type(false, semantic_tag::none);`
`1238`		`- }`
	`1217`	`+ return value_type(false, semantic_tag::none);`
`1239`	`1218`	`}`
`1240`	`1219`
`1241`	`1220`	`std::string to_string(int level) const override`
`@@ -1294,10 +1273,7 @@ namespace detail {`
`1294`	`1273`	`{`
`1295`	`1274`	`return value_type(true, semantic_tag::none);`
`1296`	`1275`	`}`
`1297`		`- else`
`1298`		`- {`
`1299`		`- return value_type(false, semantic_tag::none);`
`1300`		`- }`
	`1276`	`+ return value_type(false, semantic_tag::none);`
`1301`	`1277`	`}`
`1302`	`1278`
`1303`	`1279`	`std::string to_string(int level) const override`
`@@ -1590,7 +1566,7 @@ namespace detail {`
`1590`	`1566`	`{`
`1591`	`1567`	`return value_type(sn, semantic_tag::none);`
`1592`	`1568`	`}`
`1593`		`- jsoncons::detail::chars_to to_double;`
	`1569`	`+ jsoncons::detail::chars_to to_double{};`
`1594`	`1570`	`try`
`1595`	`1571`	`{`
`1596`	`1572`	`auto s = arg0.as_string();`
`@@ -2405,7 +2381,7 @@ namespace detail {`
`2405`	`2381`	`{`
`2406`	`2382`	`}`
`2407`	`2383`
`2408`		`- virtual std::string to_string(int = 0) const`
	`2384`	`+ virtual std::string to_string(int) const`
`2409`	`2385`	`{`
`2410`	`2386`	`return std::string();`
`2411`	`2387`	`}`
`@@ -2528,15 +2504,9 @@ namespace detail {`
`2528`	`2504`	`ec = jsonpath_errc::unknown_function;`
`2529`	`2505`	`return nullptr;`
`2530`	`2506`	`}`
`2531`		`- else`
`2532`		`- {`
`2533`		`- return it2->second.get();`
`2534`		`- }`
`2535`		`- }`
`2536`		`- else`
`2537`		`- {`
`2538`		`- return it->second.get();`
	`2507`	`+ return it2->second.get();`
`2539`	`2508`	`}`
	`2509`	`+ return it->second.get();`
`2540`	`2510`	`}`
`2541`	`2511`
`2542`	`2512`	`const unary_operator<Json>* get_unary_not() const`
Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ namespace jsoncons { namespace jsonpath {`
`164`	`164`	`return std::error_code(static_cast<int>(result),jsonpath_error_category());`
`165`	`165`	`}`
`166`	`166`
`167`		`-} // jsonpath`
	`167`	`+} // namespace jsonpath`
`168`	`168`	`} // namespace jsoncons`
`169`	`169`
`170`	`170`	`namespace std {`
Original file line number	Diff line number	Diff line change
`@@ -198,7 +198,7 @@ namespace msgpack {`
`198`	`198`	`return val;`
`199`	`199`	`}`
`200`	`200`
`201`		`-} // msgpack`
	`201`	`+} // namespace msgpack`
`202`	`202`	`} // namespace jsoncons`
`203`	`203`
`204`	`204`	`#endif // JSONCONS_EXT_MSGPACK_DECODE_MSGPACK_HPP`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ namespace msgpack {`
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`
`140`		`-} // msgpack`
	`140`	`+} // namespace msgpack`
`141`	`141`	`} // namespace jsoncons`
`142`	`142`
`143`	`143`	`#endif // JSONCONS_EXT_MSGPACK_ENCODE_MSGPACK_HPP`
Original file line number	Diff line number	Diff line change
`@@ -197,7 +197,7 @@ namespace ubjson {`
`197`	`197`	`return val;`
`198`	`198`	`}`
`199`	`199`
`200`		`-} // ubjson`
	`200`	`+} // namespace ubjson`
`201`	`201`	`} // namespace jsoncons`
`202`	`202`
`203`	`203`	`#endif // JSONCONS_EXT_UBJSON_DECODE_UBJSON_HPP`