Overwork documentation (#4516)

Author: nlohmann

.github/workflows/publish_documentation.yml

@@ -25,9 +25,6 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Install and update PlantUML
-        run: sudo apt-get update ; sudo apt-get install -y plantuml
-
       - name: Install virtual environment
         run: make install_venv -C docs/mkdocs
 

CMakeLists.txt

@@ -81,23 +81,23 @@ else()
 endif()
 
 if (NOT JSON_ImplicitConversions)
-    message(STATUS "Implicit conversions are disabled")
+    message(STATUS "Implicit conversions are disabled (JSON_USE_IMPLICIT_CONVERSIONS=0)")
 endif()
 
 if (JSON_DisableEnumSerialization)
-    message(STATUS "Enum integer serialization is disabled")
+    message(STATUS "Enum integer serialization is disabled (JSON_DISABLE_ENUM_SERIALIZATION=0)")
 endif()
 
 if (JSON_LegacyDiscardedValueComparison)
-    message(STATUS "Legacy discarded value comparison enabled")
+    message(STATUS "Legacy discarded value comparison enabled (JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1)")
 endif()
 
 if (JSON_Diagnostics)
-    message(STATUS "Diagnostics enabled")
+    message(STATUS "Diagnostics enabled (JSON_DIAGNOSTICS=1)")
 endif()
 
 if (NOT JSON_GlobalUDLs)
-    message(STATUS "User-defined string literals are not put in the global namespace")
+    message(STATUS "User-defined string literals are not put in the global namespace (JSON_USE_GLOBAL_UDLS=0)")
 endif()
 
 if (JSON_SystemInclude)

README.md

@@ -39,6 +39,7 @@
   - [Conversions to/from arbitrary types](#arbitrary-types-conversions)
   - [Specializing enum conversion](#specializing-enum-conversion)
   - [Binary formats (BSON, CBOR, MessagePack, UBJSON, and BJData)](#binary-formats-bson-cbor-messagepack-ubjson-and-bjdata)
+- [Customers](#customers)
 - [Supported compilers](#supported-compilers)
 - [Integration](#integration)
   - [CMake](#cmake)
@@ -1112,6 +1113,11 @@ binary.set_subtype(0x10);
 auto cbor = json::to_msgpack(j); // 0xD5 (fixext2), 0x10, 0xCA, 0xFE
 ```
 
+## Customers
+
+The library is used in multiple projects, applications, operating systems, etc. The list below is not exhaustive, but the result of an internet search. If you know further customers of the library, please let me know, see [contact](#contact).
+
+[![](docs/mkdocs/docs/images/customers.png)](https://json.nlohmann.me/home/customers/)
 
 ## Supported compilers
 

cmake/ci.cmake

@@ -1024,8 +1024,8 @@ add_custom_target(ci_test_examples
 )
 
 add_custom_target(ci_test_api_documentation
-    COMMAND ${Python3_EXECUTABLE} scripts/check_structure.py
-    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/docs/mkdocs
+    COMMAND ${Python3_EXECUTABLE} ../scripts/check_structure.py
+    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/docs/mkdocs/docs
     COMMENT "Lint the API documentation"
 )
 

docs/mkdocs/Makefile

@@ -35,3 +35,11 @@ install_venv: requirements.txt
 # uninstall the virtual environment
 uninstall_venv: clean
 	rm -fr venv
+
+update_requirements:
+	rm -fr venv_small
+	python3 -mvenv venv_small
+	venv_small/bin/pip3 install pur
+	venv_small/bin/pur -r requirements.txt
+	rm -fr venv_small venv
+	make install_venv

docs/mkdocs/docs/api/basic_json/accept.md

@@ -29,9 +29,9 @@ Unlike the [`parse`](parse.md) function, this function neither throws an excepti
 :   A compatible input, for instance:
     
     - an `std::istream` object
-    - a `FILE` pointer (must not be null)
+    - a `FILE` pointer (throws if null)
     - a C-style array of characters
-    - a pointer to a null-terminated string of single byte characters
+    - a pointer to a null-terminated string of single byte characters (throws if null)
     - a `std::string`
     - an object `obj` for which `begin(obj)` and `end(obj)` produces a valid pair of iterators.
 
@@ -64,18 +64,17 @@ Whether the input is valid JSON.
 
 Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
 
+## Exceptions
+
+Throws [`parse_error.101`](../../home/exceptions.md#jsonexceptionparse_error101) in case of an empty input like a null `FILE*` or `char*` pointer.
+
 ## Complexity
 
 Linear in the length of the input. The parser is a predictive LL(1) parser.
 
 ## Notes
 
-(1) A UTF-8 byte order mark is silently ignored.
-
-!!! danger "Runtime assertion"
-
-    The precondition that a passed `#!cpp FILE` pointer must not be null is enforced with a
-    [runtime assertion](../../features/assertions.md).
+A UTF-8 byte order mark is silently ignored.
 
 ## Examples
 
@@ -102,6 +101,7 @@ Linear in the length of the input. The parser is a predictive LL(1) parser.
 
 - Added in version 3.0.0.
 - Ignoring comments via `ignore_comments` added in version 3.9.0.
+- Changed [runtime assertion](../../features/assertions.md) in case of `FILE*` null pointers to exception in version 3.11.4.
 
 !!! warning "Deprecation"
 

docs/mkdocs/docs/api/basic_json/emplace.md

@@ -14,6 +14,11 @@ created from `args`.
 `Args`
 :   compatible types to create a `basic_json` object
 
+## Iterator invalidation
+
+For [`ordered_json`](../ordered_json.md), adding a value to an object can yield a reallocation, in which case all
+iterators (including the `end()` iterator) and all references to the elements are invalidated.
+
 ## Parameters
 
 `args` (in)

docs/mkdocs/docs/api/basic_json/emplace_back.md

@@ -13,6 +13,12 @@ Creates a JSON value from the passed parameters `args` to the end of the JSON va
 `Args`
 :   compatible types to create a `basic_json` object
 
+## Iterator invalidation
+
+By adding an element to the end of the array, a reallocation can happen, in which case all iterators (including the
+[`end()`](end.md) iterator) and all references to the elements are invalidated. Otherwise, only the [`end()`](end.md)
+iterator is invalidated.
+
 ## Parameters
 
 `args` (in)
@@ -48,6 +54,11 @@ Amortized constant.
     --8<-- "examples/emplace_back.output"
     ```
 
+## See also
+
+- [operator+=](operator+=.md) add a value to an array/object
+- [push_back](push_back.md) add a value to an array/object
+
 ## Version history
 
 - Since version 2.0.8.

docs/mkdocs/docs/api/basic_json/exception.md

@@ -8,24 +8,36 @@ This class is an extension of [`std::exception`](https://en.cppreference.com/w/c
 member `id` for exception ids. It is used as the base class for all exceptions thrown by the `basic_json` class. This
 class can hence be used as "wildcard" to catch exceptions, see example below.
 
-```plantuml
-std::exception <|-- basic_json::exception
-basic_json::exception <|-- basic_json::parse_error
-basic_json::exception <|-- basic_json::invalid_iterator
-basic_json::exception <|-- basic_json::type_error
-basic_json::exception <|-- basic_json::out_of_range
-basic_json::exception <|-- basic_json::other_error
-
-interface std::exception {}
-
-class basic_json::exception #FFFF00 {
-    + const int id
-    + const char* what() const
-}
-
-class basic_json::parse_error {
-    + const std::size_t byte
-}
+```mermaid
+classDiagram
+  direction LR
+  
+    class std_exception ["std::exception"] {
+        <<interface>>
+    }
+
+    class json_exception ["basic_json::exception"] {
+        +const int id
+        +const char* what() const
+    }
+    
+    class json_parse_error ["basic_json::parse_error"] {
+        +const std::size_t byte
+    }
+
+    class json_invalid_iterator ["basic_json::invalid_iterator"]
+    class json_type_error ["basic_json::type_error"]
+    class json_out_of_range ["basic_json::out_of_range"]
+    class json_other_error ["basic_json::other_error"]
+
+    std_exception <|-- json_exception
+    json_exception <|-- json_parse_error
+    json_exception <|-- json_invalid_iterator
+    json_exception <|-- json_type_error
+    json_exception <|-- json_out_of_range
+    json_exception <|-- json_other_error
+
+    style json_exception fill:#CCCCFF
 ```
 
 Subclasses:

docs/mkdocs/docs/api/basic_json/get_ptr.md

@@ -37,7 +37,9 @@ Constant.
 
     The pointer becomes invalid if the underlying JSON object changes.
 
-    Consider the following example code where the pointer `ptr` changes after the array is resized. As a result, reading or writing to `ptr` after the array change would be undefined behavior. The address of the first array element changes, because the underlying `std::vector` is resized after adding a fifth element.
+    Consider the following example code where the pointer `ptr` changes after the array is resized. As a result,
+    reading or writing to `ptr` after the array change would be undefined behavior. The address of the first array
+    element changes, because the underlying `std::vector` is resized after adding a fifth element.
 
     ```cpp
     #include <iostream>