deploy: 40a62947d3

api/basic_json/format_as.md

@@ -57,7 +57,68 @@ std::string format_as(const BasicJsonType& j)
     `#!cpp "{:.>#}"`), define your own `fmt::formatter` specialization mirroring the same logic:
 
     ```cpp
-    --8<-- "../../../tests/fmt_formatter/project/main.cpp:formatter_recipe"
+    template <>
+    struct fmt::formatter<nlohmann::json>
+    {
+        // -1 means compact output (dump()); any value >= 0 means pretty-printed
+        // output with that many spaces (or indent_char) per level.
+        int indent = -1;
+        char indent_char = ' ';
+    
+        constexpr auto parse(format_parse_context& ctx) -> format_parse_context::iterator
+        {
+            auto it = ctx.begin();
+            const auto end = ctx.end();
+            constexpr auto is_align = [](char c)
+            {
+                return c == '<' || c == '>' || c == '^';
+            };
+    
+            // [[fill] align] - repurposed here to pick a custom indent character
+            if (it != end && it + 1 != end && is_align(it[1]))
+            {
+                indent_char = *it;
+                it += 2;
+            }
+            else if (it != end && is_align(*it))
+            {
+                ++it;
+            }
+    
+            // ['#'] - "alternate form", used here to request pretty-printing with a
+            // default indent of 4 (overridden by an explicit width below, if given)
+            if (it != end && *it == '#')
+            {
+                indent = 4;
+                ++it;
+            }
+    
+            // [width] - repurposed here to pick the indent size; a width without '#'
+            // implies pretty-printing since an indent otherwise has no meaning
+            if (it != end && *it >= '1' && *it <= '9')
+            {
+                indent = 0;
+                while (it != end && *it >= '0' && *it <= '9')
+                {
+                    indent = (indent * 10) + (*it - '0');
+                    ++it;
+                }
+            }
+    
+            if (it != end && *it != '}')
+            {
+                throw fmt::format_error("invalid format args for nlohmann::json");
+            }
+    
+            return it;
+        }
+    
+        auto format(const nlohmann::json& j, format_context& ctx) const
+        {
+            const auto dumped = j.dump(indent, indent_char);
+            return fmt::format_to(ctx.out(), "{}", dumped);
+        }
+    };
     ```
 
     This recipe isn't shipped by the library itself, since doing so would make `fmt` a build dependency
@@ -75,13 +136,30 @@ std::string format_as(const BasicJsonType& j)
     allowing argument-dependent lookup.
 
     ```cpp
-    --8<-- "examples/format_as.cpp"
+    #include <iostream>
+    #include <nlohmann/json.hpp>
+    
+    using json = nlohmann::json;
+    
+    int main()
+    {
+        // create a JSON value
+        json j = {{"one", 1}, {"two", 2}};
+    
+        // format_as() is found via argument-dependent lookup, the same way
+        // fmt::format/fmt::print would find it
+        auto j_str = format_as(j);
+    
+        std::cout << j_str << std::endl;
+    }
+    
     ```
 
     Output:
 
     ```json
-    --8<-- "examples/format_as.output"
+    {"one":1,"two":2}
+    
     ```
 
 ## See also