deploy: 40a62947d3

api/basic_json/to_ubjson.md

@@ -75,13 +75,81 @@ Linear in the size of the JSON value `j`.
     The example shows the serialization of a JSON value to a byte vector in UBJSON format.
      
     ```cpp
-    --8<-- "examples/to_ubjson.cpp"
+    #include <iostream>
+    #include <iomanip>
+    #include <nlohmann/json.hpp>
+    
+    using json = nlohmann::json;
+    using namespace nlohmann::literals;
+    
+    // function to print UBJSON's diagnostic format
+    void print_byte(uint8_t byte)
+    {
+        if (32 < byte and byte < 128)
+        {
+            std::cout << (char)byte;
+        }
+        else
+        {
+            std::cout << (int)byte;
+        }
+    }
+    
+    int main()
+    {
+        // create a JSON value
+        json j = R"({"compact": true, "schema": false})"_json;
+    
+        // serialize it to UBJSON
+        std::vector<std::uint8_t> v = json::to_ubjson(j);
+    
+        // print the vector content
+        for (auto& byte : v)
+        {
+            print_byte(byte);
+        }
+        std::cout << std::endl;
+    
+        // create an array of numbers
+        json array = {1, 2, 3, 4, 5, 6, 7, 8};
+    
+        // serialize it to UBJSON using default representation
+        std::vector<std::uint8_t> v_array = json::to_ubjson(array);
+        // serialize it to UBJSON using size optimization
+        std::vector<std::uint8_t> v_array_size = json::to_ubjson(array, true);
+        // serialize it to UBJSON using type optimization
+        std::vector<std::uint8_t> v_array_size_and_type = json::to_ubjson(array, true, true);
+    
+        // print the vector contents
+        for (auto& byte : v_array)
+        {
+            print_byte(byte);
+        }
+        std::cout << std::endl;
+    
+        for (auto& byte : v_array_size)
+        {
+            print_byte(byte);
+        }
+        std::cout << std::endl;
+    
+        for (auto& byte : v_array_size_and_type)
+        {
+            print_byte(byte);
+        }
+        std::cout << std::endl;
+    }
+    
     ```
     
     Output:
     
     ```json
-    --8<-- "examples/to_ubjson.output"
+    {i7compactTi6schemaF}
+    [i1i2i3i4i5i6i7i8]
+    [#i8i1i2i3i4i5i6i7i8
+    [$i#i812345678
+    
     ```
 
 ??? example "Example: other_error.502 exception"
@@ -90,13 +158,34 @@ Linear in the size of the JSON value `j`.
     exception, because type-optimized containers can only be read back with a preceding size.
 
     ```cpp
-    --8<-- "examples/to_ubjson__exception.cpp"
+    #include <iostream>
+    #include <nlohmann/json.hpp>
+    
+    using json = nlohmann::json;
+    
+    int main()
+    {
+        // create a non-empty JSON array
+        json j = {1, 2, 3};
+    
+        // exception other_error.502
+        try
+        {
+            json::to_ubjson(j, false, true);
+        }
+        catch (const json::other_error& e)
+        {
+            std::cout << e.what() << '\n';
+        }
+    }
+    
     ```
 
     Output:
 
     ```json
-    --8<-- "examples/to_ubjson__exception.output"
+    [json.exception.other_error.502] use_type requires use_size = true
+    
     ```
 
 ## See also