VariantAttorney: replace ResultOfGetData with a trailing return type

Ported from ecbc8e85d4

.clang-format

@@ -1,5 +1,12 @@
 # http://clang.llvm.org/docs/ClangFormatStyleOptions.html
 
 BasedOnStyle: Google
-Standard: Cpp03
+Standard: c++11
 AllowShortFunctionsOnASingleLine: Empty
+IncludeBlocks: Preserve
+IndentPPDirectives: AfterHash
+DerivePointerAlignment: false
+
+# Always break after if to get accurate coverage
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

.github/FUNDING.yml

@@ -1 +1,4 @@
-custom: https://arduinojson.org/book/
+github: bblanchon
+custom:
+  - https://arduinojson.org/book/
+  - https://donate.benoitblanchon.fr/

.github/ISSUE_TEMPLATE.md

@@ -1,14 +0,0 @@
-<!--
-Before opening an issue, please read the FAQ:
-https://arduinojson.org/faq/
-
-Please provide all the relevant information:
-* good title
-* short description of the problem
-* target platform
-* compiler model and version
-* MVCE (https://stackoverflow.com/help/mcve)
-* compiler output
-
-Good questions get fast answers!
--->

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,54 @@
+---
+name: 🐛 Bug report
+about: Report a bug in ArduinoJson
+title: ''
+labels: 'bug'
+assignees: ''
+---
+
+<!-- ⚠️ IMPORTANT ⚠️
+Before opening a bug report, please use the ArduinoJson Troubleshooter as it may find a solution to your issue; if not, please include the  Troubleshooter's report in the description.
+-->
+
+**Describe the bug**  
+A clear and concise description of what the bug is.
+
+**Troubleshooter report**  
+Here is the report generated by the [ArduinoJson Troubleshooter](https://arduinojson.org/v6/troubleshooter/):  
+[Paste the report here]
+
+**Environment**  
+Here is the environment that I used:
+* Microcontroller: [e.g. ESP8266]
+* Core/runtime: [e.g. ESP8266 core for Arduino v3.0.2]
+* IDE: [e.g. Arduino IDE 1.8.16]
+
+**Reproduction**  
+Here is a small snippet that reproduces the issue.
+
+```c++
+JsonDocument doc(1024);
+
+DeserializationError error = deserializeJson(doc, "{\"hello\":\"world\"}");
+
+[insert repro code here]
+```
+
+**Compiler output**    
+If relevant, include the complete compiler output (i.e. not just the line that contains the error.)
+
+
+**Program output**  
+If relevant, include the repro program output.
+
+Expected output:
+
+```
+[insert expected output here]
+```
+
+Actual output:
+
+```
+[insert actual output here]
+```

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: true
+contact_links:
+  - name: 👨‍🏫 ArduinoJson Assistant
+    url: https://arduinojson.org/v6/assistant/
+    about: An online tool that computes memory requirements and generates scaffolding code for your project.
+  - name: 👨‍⚕️ ArduinoJson Troubleshooter
+    url: https://arduinojson.org/v6/troubleshooter/
+    about: An online tool that helps you diagnose the most common issues with ArduinoJson.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,19 @@
+---
+name: 💡 Feature request
+about: Suggest an idea for ArduinoJson
+title: ''
+labels: enhancement
+assignees: ''
+---
+
+**Is your feature request related to a problem? Please describe.**  
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**  
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**  
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**  
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/help.md

@@ -0,0 +1,51 @@
+---
+name: 😭 Help!
+about: Ask for help
+title: ''
+labels: 'question'
+assignees: ''
+---
+
+<!-- ⚠️ IMPORTANT ⚠️
+Before asking for help, please use the ArduinoJson Troubleshooter as it may find a solution to your issue; if not, please include the  Troubleshooter's report in the description.
+-->
+
+**Describe the issue**  
+A clear and concise description of what you're trying to do.
+You don't need to explain every aspect of your project: focus on the problem you're having.
+
+**Troubleshooter report**  
+Here is the report generated by the [ArduinoJson Troubleshooter](https://arduinojson.org/v6/troubleshooter/):  
+[Paste the report here]
+
+**Environment**  
+Here is the environment that I'm using':
+* Microconroller: [e.g. ESP8266]
+* Core/runtime: [e.g. ESP8266 core for Arduino v3.0.2]
+* IDE: [e.g. Arduino IDE 1.8.16]
+
+**Reproduction**  
+Here is a small snippet that demonstrate the problem.
+
+```c++
+JsonDocument doc(1024);
+
+DeserializationError error = deserializeJson(doc, "{\"hello\":\"world\"}");
+
+// insert code here
+```
+
+**Program output**  
+If relevant, include the program output.
+
+Expected output:
+
+```
+[insert expected output here]
+```
+
+Actual output:
+
+```
+[insert actual output here]
+```

.github/lock.yml

@@ -1,7 +0,0 @@
-# Configuration for Lock Threads - https://github.com/dessant/lock-threads
-
-# Number of days of inactivity before a closed issue or pull request is locked
-daysUntilLock: 30
-
-# Comment to post before locking. Set to `false` to disable
-lockComment: false

.github/workflows/ci.yml

@@ -0,0 +1,589 @@
+name: Continuous Integration
+
+on: [push, pull_request]
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Install
+        run: sudo apt-get install -y clang-format
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Symlinks
+        run: find * -type l -printf "::error::%p is a symlink. This is forbidden by the Arduino Library Specification." -exec false {} +
+      - name: Clang-format
+        run: |
+          find src/ extras/ -name '*.[ch]pp' | xargs clang-format -i --verbose --style=file
+          git diff --exit-code
+      - name: Check URLs
+        run: |
+          grep -hREo "(http|https)://[a-zA-Z0-9./?=_%:-]*" src/ | sort -u | while read -r URL
+          do
+            STATUS=$(curl -s -o /dev/null -I -w "%{http_code}" "$URL")
+            [ "$STATUS" -ge 400 ] && echo "::warning title=HTTP $STATUS::$URL returned $STATUS"
+          done || true
+
+  gcc:
+    name: GCC
+    needs: lint
+    runs-on: ubuntu-22.04
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - gcc: "5"
+          - gcc: "6"
+          - gcc: "7"
+            cxxflags: -fsanitize=leak -fno-sanitize-recover=all
+          - gcc: "8"
+            cxxflags: -fsanitize=undefined -fno-sanitize-recover=all
+          - gcc: "9"
+            cxxflags: -fsanitize=address -fno-sanitize-recover=all
+          - gcc: "10"
+            cxxflags: -funsigned-char # Issue #1715
+          - gcc: "11"
+    steps:
+      - name: Install
+        run: |
+          sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 40976EAF437D05B5 3B4FE6ACC0B21F32
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ bionic main universe'
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ focal main universe'
+          sudo apt-get update
+          sudo apt-get install -y gcc-${{ matrix.gcc }} g++-${{ matrix.gcc }}
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Configure
+        run: cmake -DCMAKE_BUILD_TYPE=Debug .
+        env:
+          CC: gcc-${{ matrix.gcc }}
+          CXX: g++-${{ matrix.gcc }}
+          CXXFLAGS: ${{ matrix.cxxflags }}
+      - name: Build
+        run: cmake --build .
+      - name: Test
+        run: |
+          echo "## CTest output" >> $GITHUB_STEP_SUMMARY
+          echo '```' >> $GITHUB_STEP_SUMMARY
+          ctest --output-on-failure -C Debug . | tee -a $GITHUB_STEP_SUMMARY
+          echo '```' >> $GITHUB_STEP_SUMMARY
+        env:
+          UBSAN_OPTIONS: print_stacktrace=1
+
+  clang:
+    name: Clang
+    needs: lint
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - clang: "3.8"
+            cxxflags: "-stdlib=libc++"
+          - clang: "3.9"
+            cxxflags: "-stdlib=libc++"
+          - clang: "4.0"
+            cxxflags: "-stdlib=libc++"
+          - clang: "5.0"
+          - clang: "6.0"
+          - clang: "7"
+          - clang: "8"
+            cxxflags: -fsanitize=leak -fno-sanitize-recover=all
+          - clang: "9"
+            cxxflags: -fsanitize=undefined -fno-sanitize-recover=all
+          - clang: "10"
+            cxxflags: -fsanitize=address -fno-sanitize-recover=all
+    steps:
+      - name: Install
+        run: |
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ xenial main'
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ xenial universe'
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ bionic main'
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ bionic universe'
+          sudo apt-get update
+          sudo apt-get install -y clang-${{ matrix.clang }}
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Configure
+        run: cmake -DCMAKE_BUILD_TYPE=Debug .
+        env:
+          CC: clang-${{ matrix.clang }}
+          CXX: clang++-${{ matrix.clang }}
+          CXXFLAGS: >-
+            ${{ matrix.cxxflags }}
+            ${{ contains(matrix.cxxflags, 'libc++') && '-I/usr/lib/llvm-10/include/c++/v1/' || '' }}
+      - name: Build
+        run: cmake --build .
+      - name: Test
+        run: |
+          echo "## CTest output" >> $GITHUB_STEP_SUMMARY
+          echo '```' >> $GITHUB_STEP_SUMMARY
+          ctest --output-on-failure -C Debug . | tee -a $GITHUB_STEP_SUMMARY
+          echo '```' >> $GITHUB_STEP_SUMMARY
+        env:
+          UBSAN_OPTIONS: print_stacktrace=1
+
+  conf_test:
+    name: Test configuration on Linux
+    needs: [gcc, clang]
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Install
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y g++-multilib gcc-avr avr-libc
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: AVR
+        run: avr-g++ -std=c++11 -Isrc extras/conf_test/avr.cpp
+      - name: GCC 32-bit
+        run: g++ -std=c++11 -m32 -Isrc extras/conf_test/x86.cpp
+      - name: GCC 64-bit
+        run: g++ -std=c++11 -m64 -Isrc extras/conf_test/x64.cpp
+      - name: Clang 32-bit
+        run: clang++ -std=c++11 -m32 -Isrc extras/conf_test/x86.cpp
+      - name: Clang 64-bit
+        run: clang++ -std=c++11 -m64 -Isrc extras/conf_test/x64.cpp
+
+  conf_test_windows:
+    name: Test configuration on Windows
+    runs-on: windows-2019
+    needs: [gcc, clang]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: 32-bit
+        run: |
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars32.bat"
+          cl /Isrc extras/conf_test/x86.cpp
+        shell: cmd
+      - name: 64-bit
+        run: |
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+          cl /Isrc extras/conf_test/x64.cpp
+        shell: cmd
+
+  xcode:
+    name: XCode
+    needs: clang
+    runs-on: macos-11
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - xcode: "11.7"
+          - xcode: "12.4"
+          - xcode: "13.2.1"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Select XCode version
+        run: sudo xcode-select --switch /Applications/Xcode_${{ matrix.xcode }}.app
+      - name: Configure
+        run: cmake -DCMAKE_BUILD_TYPE=Debug .
+      - name: Build
+        run: cmake --build .
+      - name: Test
+        run: ctest --output-on-failure -C Debug .
+
+  # DISABLED: Running on AppVeyor instead because it supports older versions of the compiler
+  # msvc:
+  #   name: Visual Studio
+  #   strategy:
+  #     fail-fast: false
+  #     matrix:
+  #       include:
+  #         - os: windows-2016
+  #         - os: windows-2019
+  #   runs-on: ${{ matrix.os }}
+  #   steps:
+  #     - name: Checkout
+  #       uses: actions/checkout@v3
+  #     - name: Configure
+  #       run: cmake -DCMAKE_BUILD_TYPE=Debug .
+  #     - name: Build
+  #       run: cmake --build .
+  #     - name: Test
+  #       run: ctest --output-on-failure -C Debug .
+
+  arduino:
+    name: Arduino
+    needs: gcc
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - core: arduino:avr
+            board: arduino:avr:uno
+          - core: arduino:samd
+            board: arduino:samd:mkr1000
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Install arduino-cli
+        run: curl -fsSL https://raw.githubusercontent.com/arduino/arduino-cli/master/install.sh | BINDIR=/usr/local/bin sh
+      - name: Install core
+        run: arduino-cli core install ${{ matrix.core }}
+      - name: Install libraries
+        run: arduino-cli lib install SD Ethernet
+      - name: Build JsonConfigFile
+        run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} "examples/JsonConfigFile/JsonConfigFile.ino"
+      - name: Build JsonFilterExample
+        run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} "examples/JsonFilterExample/JsonFilterExample.ino"
+      - name: Build JsonGeneratorExample
+        run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} "examples/JsonGeneratorExample/JsonGeneratorExample.ino"
+      - name: Build JsonHttpClient
+        run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} "examples/JsonHttpClient/JsonHttpClient.ino"
+      - name: Build JsonParserExample
+        run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} "examples/JsonParserExample/JsonParserExample.ino"
+      - name: Build JsonServer
+        run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} "examples/JsonServer/JsonServer.ino"
+      - name: Build JsonUdpBeacon
+        run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} "examples/JsonUdpBeacon/JsonUdpBeacon.ino"
+      - name: Build MsgPackParser
+        run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} "examples/MsgPackParser/MsgPackParser.ino"
+      - name: Build ProgmemExample
+        run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} "examples/ProgmemExample/ProgmemExample.ino"
+      - name: Build StringExample
+        run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} "examples/StringExample/StringExample.ino"
+
+  platformio:
+    name: PlatformIO
+    needs: gcc
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: atmelavr
+            board: leonardo
+            libraries:
+              - SD
+              - Ethernet
+            conf_test: avr
+          - platform: espressif8266
+            board: huzzah
+            conf_test: esp8266
+          - platform: espressif32
+            board: esp32dev
+            libraries:
+              - Ethernet
+            conf_test: esp8266
+          - platform: atmelsam
+            board: mkr1000USB
+            libraries:
+              - SD
+              - Ethernet
+            conf_test: esp8266
+          - platform: teensy
+            board: teensy31
+            conf_test: esp8266
+          - platform: ststm32
+            board: adafruit_feather_f405
+            libraries:
+              - SD
+              - Ethernet
+            conf_test: esp8266
+          - platform: nordicnrf52
+            board: adafruit_feather_nrf52840
+            libraries:
+              - SD
+              - Ethernet
+            conf_test: esp8266
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Set up cache for pip
+        uses: actions/cache@v3
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip
+      - name: Set up Python 3.x
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.x"
+      - name: Install PlatformIO
+        run: pip install platformio
+      - name: Install adafruit-nrfutil
+        if: ${{ matrix.platform == 'nordicnrf52' }}
+        run: pip install adafruit-nrfutil
+      - name: Include Adafruit_TinyUSB.h # https://github.com/adafruit/Adafruit_nRF52_Arduino/issues/653
+        if: ${{ matrix.platform == 'nordicnrf52' }}
+        run: find examples/ -name '*.ino' -exec sed -i 's/\(#include <ArduinoJson.h>\)/\1\n#include <Adafruit_TinyUSB.h>/' {} +
+      - name: Set up cache for platformio
+        uses: actions/cache@v3
+        with:
+          path: ~/.platformio
+          key: ${{ runner.os }}-platformio-${{ matrix.platform }}
+      - name: Install platform "${{ matrix.platform }}"
+        run: platformio platform install ${{ matrix.platform }}
+      - name: Install libraries
+        if: ${{ matrix.libraries }}
+        run: platformio lib install arduino-libraries/${{ join(matrix.libraries, ' arduino-libraries/') }}
+      - name: Test configuration
+        run: platformio ci "extras/conf_test/${{ matrix.conf_test }}.cpp" -l '.' -b ${{ matrix.board }}
+        if: ${{ matrix.conf_test }}
+      - name: Build JsonConfigFile
+        run: platformio ci "examples/JsonConfigFile/JsonConfigFile.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build JsonFilterExample
+        run: platformio ci "examples/JsonFilterExample/JsonFilterExample.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build JsonGeneratorExample
+        run: platformio ci "examples/JsonGeneratorExample/JsonGeneratorExample.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build JsonHttpClient
+        run: platformio ci "examples/JsonHttpClient/JsonHttpClient.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build JsonParserExample
+        run: platformio ci "examples/JsonParserExample/JsonParserExample.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build JsonServer
+        if: ${{ matrix.platform != 'espressif32' }}
+        run: platformio ci "examples/JsonServer/JsonServer.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build JsonUdpBeacon
+        run: platformio ci "examples/JsonUdpBeacon/JsonUdpBeacon.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build MsgPackParser
+        run: platformio ci "examples/MsgPackParser/MsgPackParser.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build ProgmemExample
+        run: platformio ci "examples/ProgmemExample/ProgmemExample.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build StringExample
+        run: platformio ci "examples/StringExample/StringExample.ino" -l '.' -b ${{ matrix.board }}
+      - name: PlatformIO prune
+        if: ${{ always() }}
+        run: platformio system prune -f
+
+  particle:
+    name: Particle
+    needs: gcc
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push'
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - board: argon
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Install Particle CLI
+        run: sudo npm install -g particle-cli
+      - name: Login to Particle
+        run: particle login -t "${{ secrets.PARTICLE_TOKEN }}"
+      - name: Compile
+        run: extras/ci/particle.sh ${{ matrix.board }}
+
+  arm:
+    name: GCC for ARM processor
+    needs: gcc
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Install
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y g++-arm-linux-gnueabihf
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Configure
+        run: cmake .
+        env:
+          CC: arm-linux-gnueabihf-gcc
+          CXX: arm-linux-gnueabihf-g++
+      - name: Build
+        run: cmake --build .
+
+  coverage:
+    needs: gcc
+    name: Coverage
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Install
+        run: sudo apt-get install -y lcov ninja-build
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Configure
+        run: cmake -G Ninja -DCOVERAGE=true .
+      - name: Build
+        run: ninja
+      - name: Test
+        run: ctest -LE 'WillFail|Fuzzing' -T test
+      - name: lcov --capture
+        run: lcov --capture --no-external --directory . --output-file coverage.info
+      - name: lcov --remove
+        run: lcov --remove coverage.info "$(pwd)/extras/*" --output-file coverage_filtered.info
+      - name: genhtml
+        run: mkdir coverage && genhtml coverage_filtered.info -o coverage -t ArduinoJson
+      - name: Upload HTML report
+        uses: actions/upload-artifact@v3
+        with:
+          name: Coverage report
+          path: coverage
+      - name: Upload to Coveralls
+        uses: coverallsapp/github-action@master
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          path-to-lcov: coverage_filtered.info
+
+  valgrind:
+    needs: gcc
+    name: Valgrind
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Install
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y valgrind ninja-build
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Configure
+        run: cmake -G Ninja -D MEMORYCHECK_COMMAND_OPTIONS="--error-exitcode=1 --leak-check=full"  .
+      - name: Build
+        run: ninja
+      - name: Memcheck
+        run: ctest -LE WillFail -T memcheck
+        id: memcheck
+      - name: MemoryChecker.*.log
+        run: cat Testing/Temporary/MemoryChecker.*.log
+        if: failure()
+
+  clang-tidy:
+    needs: clang
+    name: Clang-Tidy
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Install
+        run: sudo apt-get install -y clang-tidy cmake ninja-build
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Configure
+        run: cmake -G Ninja -DCMAKE_CXX_CLANG_TIDY="clang-tidy-10;--warnings-as-errors=*" -DCMAKE_BUILD_TYPE=Debug .
+        env:
+          CC: clang-10
+          CXX: clang++-10
+      - name: Check
+        run: cmake --build . -- -k 0
+
+  amalgamate-h:
+    needs: gcc
+    name: Amalgamate ArduinoJson.h
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Amalgamate
+        id: amalgamate
+        run: |
+          if [[ $GITHUB_REF == refs/tags/* ]]; then
+            VERSION=${GITHUB_REF#refs/tags/}
+          else
+            VERSION=${GITHUB_SHA::7}
+          fi
+          INPUT=src/ArduinoJson.h
+          OUTPUT=ArduinoJson-$VERSION.h
+          extras/scripts/build-single-header.sh "$INPUT" "$OUTPUT"
+          echo "filename=${OUTPUT}" >> $GITHUB_OUTPUT
+      - name: Smoke test
+        run: |
+          g++ -x c++ - <<END
+          #include "${{ steps.amalgamate.outputs.filename }}"
+          int main() {
+            JsonDocument doc(300);
+            deserializeJson(doc, "{}");
+          }
+          END
+      - name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: Single headers
+          path: ${{ steps.amalgamate.outputs.filename }}
+
+  amalgamate-hpp:
+    needs: gcc
+    name: Amalgamate ArduinoJson.hpp
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Amalgamate
+        id: amalgamate
+        run: |
+          if [[ $GITHUB_REF == refs/tags/* ]]; then
+            VERSION=${GITHUB_REF#refs/tags/}
+          else
+            VERSION=${GITHUB_SHA::7}
+          fi
+          INPUT=src/ArduinoJson.hpp
+          OUTPUT=ArduinoJson-$VERSION.hpp
+          extras/scripts/build-single-header.sh "$INPUT" "$OUTPUT"
+          echo "filename=${OUTPUT}" >> $GITHUB_OUTPUT
+      - name: Smoke test
+        run: |
+          g++ -x c++ - <<END
+          #include "${{ steps.amalgamate.outputs.filename }}"
+          int main() {
+            ArduinoJson::JsonDocument doc(300);
+            deserializeJson(doc, "{}");
+          }
+          END
+      - name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: Single headers
+          path: ${{ steps.amalgamate.outputs.filename }}
+
+  esp-idf:
+    needs: gcc
+    name: ESP-IDF
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup cache
+        uses: actions/cache@v3
+        with:
+          path: ~/.espressif
+          key: ${{ runner.os }}-esp-idf
+      - name: Checkout ArduinoJson
+        uses: actions/checkout@v3
+      - name: Checkout ESP-IDF
+        uses: actions/checkout@v3
+        with:
+          repository: espressif/esp-idf
+          path: esp-idf
+          submodules: true
+      - name: Install ESP-IDF
+        run: ./esp-idf/install.sh
+      - name: Add component
+        # NOTE: we cannot commit the symlink because the Arduino Library Specification forbids it.
+        run: |
+          mkdir -p extras/ci/espidf/components
+          ln -s $PWD extras/ci/espidf/components/ArduinoJson
+      - name: Build example
+        run: |
+          source esp-idf/export.sh
+          cd extras/ci/espidf
+          idf.py build
+
+  codeql:
+    name: CodeQL
+    runs-on: ubuntu-20.04
+    needs: gcc
+
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: cpp
+
+    - name: Build
+      run: |
+        cmake -DCMAKE_BUILD_TYPE=Debug .
+        cmake --build .
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
+      with:
+        category: "/language:cpp"

.github/workflows/lock.yml

@@ -0,0 +1,14 @@
+name: Lock Threads
+
+on:
+  schedule:
+    - cron: '0 0 * * *'
+
+jobs:
+  lock:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dessant/lock-threads@v4
+        with:
+          github-token: ${{ github.token }}
+          issue-inactive-days: 30

.github/workflows/release.yml

@@ -0,0 +1,76 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - v*.*.*
+
+jobs:
+  release:
+    name: Create release
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Set variables
+        id: init
+        run: |
+          echo "tag=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
+          echo "version=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Write release body
+        id: body
+        run: |
+          FILENAME=RELEASE.md
+          extras/scripts/get-release-body.sh ${{ steps.init.outputs.tag }} CHANGELOG.md | tee $FILENAME
+          echo "filename=$FILENAME" >> $GITHUB_OUTPUT
+      - name: Amalgamate ArduinoJson.h
+        id: amalgamate_h
+        run: |
+          FILENAME=ArduinoJson-${{ steps.init.outputs.tag }}.h
+          extras/scripts/build-single-header.sh src/ArduinoJson.h "$FILENAME"
+          echo "filename=$FILENAME" >> $GITHUB_OUTPUT
+      - name: Amalgamate ArduinoJson.hpp
+        id: amalgamate_hpp
+        run: |
+          FILENAME=ArduinoJson-${{ steps.init.outputs.tag }}.hpp
+          extras/scripts/build-single-header.sh src/ArduinoJson.hpp "$FILENAME"
+          echo "filename=$FILENAME" >> $GITHUB_OUTPUT
+      - name: Create Arduino package
+        id: arduino
+        run: |
+          FILENAME=ArduinoJson-${{ steps.init.outputs.tag }}.zip
+          extras/scripts/build-arduino-package.sh . "$FILENAME"
+          echo "filename=$FILENAME" >> $GITHUB_OUTPUT
+      - name: Create release
+        uses: ncipollo/release-action@v1
+        with:
+          bodyFile: ${{ steps.body.outputs.filename }}
+          name: ArduinoJson ${{ steps.init.outputs.version }}
+          artifacts: ${{ steps.amalgamate_h.outputs.filename }},${{ steps.amalgamate_hpp.outputs.filename }},${{ steps.arduino.outputs.filename }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+  idf:
+    name: IDF Component Registry
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Upload component to the component registry
+        uses: espressif/upload-components-ci-action@v1
+        with:
+          name: ArduinoJson
+          namespace: bblanchon
+          api_token: ${{ secrets.IDF_COMPONENT_API_TOKEN }}
+
+  particle:
+    name: Particle
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install
+        run: npm install -g particle-cli
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Login
+        run: particle login --token ${{ secrets.PARTICLE_TOKEN }}
+      - name: Publish
+        run: bash -eux extras/scripts/publish-particle-library.sh

.gitignore

@@ -10,3 +10,11 @@
 /extras/fuzzing/*_fuzzer.options
 /extras/fuzzing/*_fuzzer_seed_corpus.zip
 .vs/
+/out/
+
+# Used by CI for Particle
+/src/*.ino
+/project.properties
+
+# Used by IDF
+/dist/

.mbedignore

@@ -1,6 +1,3 @@
 .github/
 examples/
-fuzzing/
-scripts/
-test/
-third-party/
+extras/

.prettierignore

@@ -0,0 +1 @@
+*.md

.travis.yml

@@ -1,132 +0,0 @@
-sudo: false
-language: cpp
-matrix:
-  include:
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.4']
-      env: SCRIPT=test _CC=gcc-4.4 _CXX=g++-4.4
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.6']
-      env: SCRIPT=test _CC=gcc-4.6 _CXX=g++-4.6
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.7']
-      env: SCRIPT=test _CC=gcc-4.7 _CXX=g++-4.7
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.8']
-      env: SCRIPT=test _CC=gcc-4.8 _CXX=g++-4.8 SANITIZE=address
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.9']
-      env: SCRIPT=test _CC=gcc-4.9 _CXX=g++-4.9 SANITIZE=leak
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-5']
-      env: SCRIPT=test _CC=gcc-5 _CXX=g++-5 # SANITIZE=undefined
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-6']
-      env: SCRIPT=test _CC=gcc-6 _CXX=g++-6
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-7']
-      env: SCRIPT=test _CC=gcc-7 _CXX=g++-7
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-8']
-      env: SCRIPT=test _CC=gcc-8 _CXX=g++-8
-    - addons:
-        apt:
-          packages: ['g++-arm-linux-gnueabihf']
-      env: SCRIPT=build _CC=arm-linux-gnueabihf-gcc _CXX=arm-linux-gnueabihf-g++
-    - env: SCRIPT=test _CC=clang _CXX=clang++
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.5']
-          packages: ['clang-3.5']
-      env: SCRIPT=test _CC=clang-3.5 _CXX=clang++-3.5 SANITIZE=address
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.6']
-          packages: ['clang-3.6']
-      env: SCRIPT=test _CC=clang-3.6 _CXX=clang++-3.6 SANITIZE=leak
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.7']
-          packages: ['clang-3.7']
-      env: SCRIPT=test _CC=clang-3.7 _CXX=clang++-3.7
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.8']
-          packages: ['clang-3.8']
-      env: SCRIPT=test _CC=clang-3.8 _CXX=clang++-3.8 SANITIZE=undefined
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-3.9']
-          packages: ['clang-3.9']
-      env: SCRIPT=test _CC=clang-3.9 _CXX=clang++-3.9
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-4.0']
-          packages: ['clang-4.0']
-      env: SCRIPT=test _CC=clang-4.0 _CXX=clang++-4.0
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['clang-5.0']
-      env: SCRIPT=test _CC=clang-5.0 _CXX=clang++-5.0
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['clang-6.0']
-      env: SCRIPT=test _CC=clang-6.0 _CXX=clang++-6.0
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-7']
-          packages: ['clang-7']
-      env: SCRIPT=test _CC=clang-7 _CXX=clang++-7
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-8']
-          packages: ['clang-8']
-      env: SCRIPT=test _CC=clang-8 _CXX=clang++-8
-    - env: SCRIPT=coverage
-    - os: osx
-      osx_image: xcode7.3
-      env: SCRIPT=test
-    - os: osx
-      osx_image: xcode8.3
-      env: SCRIPT=test
-    - os: osx
-      osx_image: xcode9.4
-      env: SCRIPT=test
-    - os: osx
-      osx_image: xcode10
-      env: SCRIPT=test SANITIZE=address
-    - env: SCRIPT=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
-    - env: SCRIPT=arduino VERSION=1.8.2 BOARD=arduino:samd:mkr1000
-    - env: SCRIPT=platformio BOARD=uno
-    - env: SCRIPT=platformio BOARD=esp01
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['clang-6.0','llvm-6.0']
-      env: SCRIPT=fuzz CLANG=6.0
-cache:
-  directories:
-    - "~/.platformio"
-    - "extras/fuzzing/json_corpus"
-    - "extras/fuzzing/msgpack_corpus"
-script: extras/ci/$SCRIPT.sh

.vscode/settings.json

@@ -0,0 +1,18 @@
+{
+  "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools",
+  "cmake.generator": "Ninja",
+  "git.inputValidationLength": 80,
+  "git.inputValidationSubjectLength": 72,
+  "files.insertFinalNewline": true,
+  "files.trimFinalNewlines": true,
+  "search.exclude": {
+    "/extras/tests/catch/*": true
+  },
+  "C_Cpp.default.includePath": [
+    "/src"
+  ],
+  "[cmake]": {
+    "editor.detectIndentation": false,
+    "editor.insertSpaces": false,
+  }
+}

ArduinoJson.h

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 
 #include "src/ArduinoJson.h"

CHANGELOG.md

@@ -1,905 +1,17 @@
 ArduinoJson: change log
 =======================
 
-v6.14.1 (2020-01-27)
--------
-
-* Fixed regression in UTF16 decoding (issue #1173)
-* Fixed `containsKey()` on `JsonVariantConst`
-* Added `getElement()` and `getMember()` to `JsonVariantConst`
-
-v6.14.0 (2020-01-16)
--------
-
-* Added `BasicJsonDocument::shrinkToFit()`
-* Added support of `uint8_t` for `serializeJson()`, `serializeJsonPretty()`, and `serializeMsgPack()` (issue #1142)
-* Added `ARDUINOJSON_ENABLE_COMMENTS` to enable support for comments (defaults to 0)
-* Auto enable support for `std::string` and `std::stream` on modern compilers (issue #1156)
-  (No need to define `ARDUINOJSON_ENABLE_STD_STRING` and `ARDUINOJSON_ENABLE_STD_STREAM` anymore)
-* Improved decoding of UTF-16 surrogate pairs (PR #1157 by @kaysievers)
-  (ArduinoJson now produces standard UTF-8 instead of CESU-8)
-* Added `measureJson`, `measureJsonPretty`, and `measureMsgPack` to `keywords.txt`
-  (This file is used for syntax highlighting in the Arduino IDE) 
-* Fixed `variant.is<nullptr_t>()`
-* Fixed value returned by `serializeJson()`, `serializeJsonPretty()`, and `serializeMsgPack()` when writing to a `String`
-* Improved speed of `serializeJson()`, `serializeJsonPretty()`, and `serializeMsgPack()` when writing to a `String`
-
-> ### BREAKING CHANGES
-> 
-> #### Comments
-> 
-> Support for comments in input is now optional and disabled by default.
->
-> If you need support for comments, you must defined `ARDUINOJSON_ENABLE_COMMENTS` to `1`; otherwise, you'll receive `InvalidInput` errors.
->
-> ```c++
-> #define ARDUINOJSON_ENABLE_COMMENTS 1
-> #include <ArduinoJson.h>
-> ```
-
-v6.13.0 (2019-11-01)
--------
-
-* Added support for custom writer/reader classes (issue #1088)
-* Added conversion from `JsonArray` and `JsonObject` to `bool`, to be consistent with `JsonVariant`
-* Fixed `deserializeJson()` when input contains duplicate keys (issue #1095)
-* Improved `deserializeMsgPack()` speed by reading several bytes at once
-* Added detection of Atmel AVR8/GNU C Compiler (issue #1112)
-* Fixed deserializer that stopped reading at the first `0xFF` (PR #1118 by @mikee47)
-* Fixed dangling reference in copies of `MemberProxy` and `ElementProxy` (issue #1120)
-
-v6.12.0 (2019-09-05)
--------
-
-* Use absolute instead of relative includes (issue #1072)
-* Changed `JsonVariant::as<bool>()` to return `true` for any non-null value (issue #1005)
-* Moved ancillary files to `extras/` (issue #1011)
-
-v6.11.5 (2019-08-23)
--------
-
-* Added fallback implementations of `strlen_P()`, `strncmp_P()`, `strcmp_P()`, and `memcpy_P()` (issue #1073)
-
-v6.11.4 (2019-08-12)
--------
-
-* Added `measureJson()` to the `ArduinoJson` namespace (PR #1069 by @nomis)
-* Added support for `basic_string<char, traits, allocator>` (issue #1045)
-* Fixed example `JsonConfigFile.ino` for ESP8266
-* Include `Arduino.h` if `ARDUINO` is defined (PR #1071 by @nomis)
-
-v6.11.3 (2019-07-22)
--------
-
-* Added operators `==` and `!=` for `JsonDocument`, `ElementProxy`, and `MemberProxy`
-* Fixed comparison of `JsonVariant` when one contains a linked string and the other contains an owned string (issue #1051)
-
-v6.11.2 (2019-07-08)
--------
-
-* Fixed assignment of `JsonDocument` to `JsonVariant` (issue #1023)
-* Fix invalid conversion error on Particle Argon (issue #1035)
-
-v6.11.1 (2019-06-21)
--------
-
-* Fixed `serialized()` not working with Flash strings (issue #1030)
-
-v6.11.0 (2019-05-26)
--------
-
-* Fixed `deserializeJson()` silently accepting a `Stream*` (issue #978)
-* Fixed invalid result from `operator|` (issue #981)
-* Made `deserializeJson()` more picky about trailing characters (issue #980)
-* Added `ARDUINOJSON_ENABLE_NAN` (default=0) to enable NaN in JSON (issue #973)
-* Added `ARDUINOJSON_ENABLE_INFINITY` (default=0) to enable Infinity in JSON
-* Removed implicit conversion in comparison operators (issue #998)
-* Added lexicographical comparison for `JsonVariant`
-* Added support for `nullptr` (issue #998)
-
-> ### BREAKING CHANGES
-> 
-> #### NaN and Infinity
-> 
-> The JSON specification allows neither NaN not Infinity, but previous
-> versions of ArduinoJson supported it. Now, ArduinoJson behaves like most
-> other libraries: a NaN or and Infinity in the `JsonDocument`, becomes
-> a `null` in the output JSON. Also, `deserializeJson()` returns
-> `InvalidInput` if the JSON document contains NaN or Infinity.
-> 
-> This version still supports NaN and Infinity in JSON documents, but
-> it's disabled by default to be compatible with other JSON parsers.
-> If you need the old behavior back, define `ARDUINOJSON_ENABLE_NAN` and
-> `ARDUINOJSON_ENABLE_INFINITY` to `1`;:
-> 
-> ```c++
-> #define ARDUINOJSON_ENABLE_NAN 1
-> #define ARDUINOJSON_ENABLE_INFINITY 1
-> #include <ArduinoJson.h>
-> ```
-> 
-> #### The "or" operator
-> 
-> This version slightly changes the behavior of the | operator when the 
-> variant contains a float and the user requests an integer.
->
-> Older versions returned the floating point value truncated.
-> Now, it returns the default value.
-> 
-> ```c++
-> // suppose variant contains 1.2
-> int value = variant | 3;
-> 
-> // old behavior:
-> value == 1
-> 
-> // new behavior
-> value == 3
-> ```
-> 
-> If you need the old behavior, you must add `if (variant.is<float>())`.
-
-v6.10.1 (2019-04-23)
--------
-
-* Fixed error "attributes are not allowed on a function-definition"
-* Fixed `deserializeJson()` not being picky enough (issue #969)
-* Fixed error "no matching function for call to write(uint8_t)" (issue #972)
-
-v6.10.0 (2019-03-22)
--------
-
-* Fixed an integer overflow in the JSON deserializer
-* Added overflow handling in `JsonVariant::as<T>()` and `JsonVariant::is<T>()`.
-   - `as<T>()` returns `0` if the integer `T` overflows
-   - `is<T>()` returns `false` if the integer `T` overflows
-* Added `BasicJsonDocument` to support custom allocator (issue #876)
-* Added `JsonDocument::containsKey()` (issue #938)
-* Added `JsonVariant::containsKey()`
-
-v6.9.1 (2019-03-01)
-------
-
-* Fixed warning "unused variable" with GCC 4.4 (issue #912)
-* Fixed warning "cast  increases required alignment" (issue #914)
-* Fixed warning "conversion may alter value" (issue #914)
-* Fixed naming conflict with "CAPACITY" (issue #839)
-* Muted warning "will change in GCC 7.1" (issue #914)
-* Added a clear error message for `StaticJsonBuffer` and `DynamicJsonBuffer`
-* Marked ArduinoJson.h  as a "system header"
-
-v6.9.0 (2019-02-26)
-------
-
-* Decode escaped Unicode characters like \u00DE (issue #304, PR #791)
-  Many thanks to Daniel Schulte (aka @trilader) who implemented this feature.
-* Added option ARDUINOJSON_DECODE_UNICODE to enable it
-* Converted `JsonArray::copyFrom()/copyTo()` to free functions `copyArray()`
-* Renamed `JsonArray::copyFrom()` and `JsonObject::copyFrom()` to `set()`
-* Renamed `JsonArray::get()` to `getElement()`
-* Renamed `JsonArray::add()` (without arg) to `addElement()`
-* Renamed `JsonObject::get()` to `getMember()`
-* Renamed `JsonObject::getOrCreate()` to `getOrAddMember()`
-* Fixed `JsonVariant::isNull()` not returning `true` after `set((char*)0)`
-* Fixed segfault after `variant.set(serialized((char*)0))`
-* Detect `IncompleteInput` in `false`, `true`, and `null`
-* Added `JsonDocument::size()`
-* Added `JsonDocument::remove()`
-* Added `JsonVariant::clear()`
-* Added `JsonVariant::remove()`
-
-v6.8.0-beta (2019-01-30)
------------
-
-* Import functions in the ArduinoJson namespace to get clearer errors
-* Improved syntax highlighting in Arduino IDE
-* Removed default capacity of `DynamicJsonDocument`
-* `JsonArray::copyFrom()` accepts `JsonArrayConst`
-* `JsonVariant::set()` accepts `JsonArrayConst` and `JsonObjectConst`
-* `JsonDocument` was missing in the ArduinoJson namespace
-* Added `memoryUsage()` to `JsonArray`, `JsonObject`, and `JsonVariant`
-* Added `nesting()` to `JsonArray`, `JsonDocument`, `JsonObject`, and `JsonVariant`
-* Replaced `JsonDocument::nestingLimit` with an additional parameter
-  to `deserializeJson()` and `deserializeMsgPack()`
-* Fixed uninitialized variant in `JsonDocument`
-* Fixed `StaticJsonDocument` copy constructor and copy assignment
-* The copy constructor of `DynamicJsonDocument` chooses the capacity according to the memory usage of the source, not from the capacity of the source.
-* Added the ability to create/assign a `StaticJsonDocument`/`DynamicJsonDocument` from a `JsonArray`/`JsonObject`/`JsonVariant`
-* Added `JsonDocument::isNull()`
-* Added `JsonDocument::operator[]`
-* Added `ARDUINOJSON_TAB` to configure the indentation character
-* Reduced the size of the pretty JSON serializer
-* Added `add()`, `createNestedArray()` and `createNestedObject()` to `JsonVariant`
-* `JsonVariant` automatically promotes to `JsonObject` or `JsonArray` on write.
-  Calling `JsonVariant::to<T>()` is not required anymore.
-* `JsonDocument` now support the same operations as `JsonVariant`.
-  Calling `JsonDocument::as<T>()` is not required anymore.
-* Fixed example `JsonHttpClient.ino`
-* User can now use a `JsonString` as a key or a value
-
-> ### BREAKING CHANGES
-> 
-> #### `DynamicJsonDocument`'s constructor
-> 
-> The parameter to the constructor of `DynamicJsonDocument` is now mandatory
->
-> Old code:
->
-> ```c++
-> DynamicJsonDocument doc;
-> ```
->
-> New code:
->
-> ```c++
-> DynamicJsonDocument doc(1024);
-> ```
-> 
-> #### Nesting limit
-> 
-> `JsonDocument::nestingLimit` was replaced with a new parameter to `deserializeJson()` and `deserializeMsgPack()`.
-> 
-> Old code:
-> 
-> ```c++
-> doc.nestingLimit = 15;
-> deserializeJson(doc, input);
-> ```
-> 
-> New code: 
-> 
-> ```c++
-> deserializeJson(doc, input, DeserializationOption::NestingLimit(15));
-> ```
-
-v6.7.0-beta (2018-12-07)
------------
-
-* Removed the automatic expansion of `DynamicJsonDocument`, it now has a fixed capacity.
-* Restored the monotonic allocator because the code was getting too big
-* Reduced the memory usage
-* Reduced the code size
-* Renamed `JsonKey` to `JsonString`
-* Removed spurious files in the Particle library
-
-v6.6.0-beta (2018-11-13)
------------
-
-* Removed `JsonArray::is<T>(i)` and `JsonArray::set(i,v)`
-* Removed `JsonObject::is<T>(k)` and `JsonObject::set(k,v)`
-* Replaced `T JsonArray::get<T>(i)` with `JsonVariant JsonArray::get(i)`
-* Replaced `T JsonObject::get<T>(k)` with `JsonVariant JsonObject::get(k)`
-* Added `JSON_STRING_SIZE()`
-* ~~Replacing or removing a value now releases the memory~~
-* Added `DeserializationError::code()` to be used in switch statements (issue #846)
-
-v6.5.0-beta (2018-10-13)
------------
-
-* Added implicit conversion from `JsonArray` and `JsonObject` to `JsonVariant`
-* Allow mixed configuration in compilation units (issue #809)
-* Fixed object keys not being duplicated
-* `JsonPair::key()` now returns a `JsonKey`
-* Increased the default capacity of `DynamicJsonDocument`
-* Fixed `JsonVariant::is<String>()` (closes #763)
-* Added `JsonArrayConst`, `JsonObjectConst`, and `JsonVariantConst`
-* Added copy-constructor and copy-assignment-operator for `JsonDocument` (issue #827)
-
-v6.4.0-beta (2018-09-11)
------------
-
-* Copy `JsonArray` and `JsonObject`, instead of storing pointers (issue #780)
-* Added `JsonVariant::to<JsonArray>()` and `JsonVariant::to<JsonObject>()`
-
-v6.3.0-beta (2018-08-31)
------------
-
-* Implemented reference semantics for `JsonVariant`
-* Replaced `JsonPair`'s `key` and `value` with `key()` and `value()`
-* Fixed `serializeJson(obj[key], dst)` (issue #794)
-
-> ### BREAKING CHANGES
->
-> #### JsonVariant
-> 
-> `JsonVariant` now has a semantic similar to `JsonObject` and `JsonArray`.
-> It's a reference to a value stored in the `JsonDocument`.
-> As a consequence, a `JsonVariant` cannot be used as a standalone variable anymore.
->
-> Old code:
->
-> ```c++
-> JsonVariant myValue = 42;
-> ```
->
-> New code:
->
-> ```c++
-> DynamicJsonDocument doc;
-> JsonVariant myValue = doc.to<JsonVariant>();
-> myValue.set(42);
-> ```
->
-> #### JsonPair
->
-> Old code:
->
-> ```c++
-> for(JsonPair p : myObject) {
->   Serial.println(p.key);
->   Serial.println(p.value.as<int>());
-> }
-> ```
->
-> New code:
->
-> ```c++
-> for(JsonPair p : myObject) {
->   Serial.println(p.key());
->   Serial.println(p.value().as<int>());
-> }
-> ```
->
-> CAUTION: the key is now read only!
-
-v6.2.3-beta (2018-07-19)
------------
-
-* Fixed exception when using Flash strings as object keys (issue #784)
-
-v6.2.2-beta (2018-07-18)
------------
-
-* Fixed `invalid application of 'sizeof' to incomplete type '__FlashStringHelper'` (issue #783)
-* Fixed `char[]` not duplicated when passed to `JsonVariant::operator[]`
-
-v6.2.1-beta (2018-07-17)
------------
-
-* Fixed `JsonObject` not inserting keys of type `String` (issue #782)
-
-v6.2.0-beta (2018-07-12)
------------
-
-* Disabled lazy number deserialization (issue #772)
-* Fixed `JsonVariant::is<int>()` that returned true for empty strings
-* Improved float serialization when `-fsingle-precision-constant` is used
-* Renamed function `RawJson()` to `serialized()`
-* `serializeMsgPack()` now supports values marked with `serialized()`
-
-> ### BREAKING CHANGES
->
-> #### Non quoted strings
->
-> Non quoted strings are now forbidden in values, but they are still allowed in keys.
-> For example, `{key:"value"}` is accepted, but `{key:value}` is not.
->
-> #### Preformatted values
->
-> Old code:
->
-> ```c++
-> object["values"] = RawJson("[1,2,3,4]");
-> ```
-> 
-> New code:
-> 
-> ```c++
-> object["values"] = serialized("[1,2,3,4]");
-> ```
-
-v6.1.0-beta (2018-07-02)
------------
-
-* Return `JsonArray` and `JsonObject` by value instead of reference (issue #309)
-* Replaced `success()` with `isNull()`
-
-> ### BREAKING CHANGES
-> 
-> Old code:
->
-> ```c++
-> JsonObject& obj = doc.to<JsonObject>();
-> JsonArray& arr = obj.createNestedArray("key");
-> if (!arr.success()) {
->   Serial.println("Not enough memory");
->   return;
-> }
-> ```
-> 
-> New code:
-> 
-> ```c++
-> JsonObject obj = doc.to<JsonObject>();
-> JsonArray arr = obj.createNestedArray("key");
-> if (arr.isNull()) {
->   Serial.println("Not enough memory");
->   return;
-> }
-> ```
-
-v6.0.1-beta (2018-06-11)
------------
-
-* Fixed conflicts with `isnan()` and `isinf()` macros (issue #752)
-
-v6.0.0-beta (2018-06-07)
------------
-
-* Added `DynamicJsonDocument` and `StaticJsonDocument`
-* Added `deserializeJson()`
-* Added `serializeJson()` and `serializeJsonPretty()`
-* Added `measureJson()` and `measureJsonPretty()`
-* Added `serializeMsgPack()`, `deserializeMsgPack()` and `measureMsgPack()` (issue #358)
-* Added example `MsgPackParser.ino` (issue #358)
-* Added support for non zero-terminated strings (issue #704)
-* Removed `JsonBuffer::parseArray()`, `parseObject()` and `parse()`
-* Removed `JsonBuffer::createArray()` and `createObject()`
-* Removed `printTo()` and `prettyPrintTo()`
-* Removed `measureLength()` and `measurePrettyLength()`
-* Removed all deprecated features
-
-> ### BREAKING CHANGES
-> 
-> #### Deserialization
-> 
-> Old code:
-> 
-> ```c++
-> DynamicJsonBuffer jb;
-> JsonObject& obj = jb.parseObject(json);
-> if (obj.success()) {
-> 
-> }
-> ```
-> 
-> New code:
-> 
-> ```c++
-> DynamicJsonDocument doc;
-> DeserializationError error = deserializeJson(doc, json);
-> if (error) {
-> 
-> }
-> JsonObject& obj = doc.as<JsonObject>();
-> ```
-> 
-> #### Serialization
-> 
-> Old code:
-> 
-> ```c++
-> DynamicJsonBuffer jb;
-> JsonObject& obj = jb.createObject();
-> obj["key"] = "value";
-> obj.printTo(Serial);
-> ```
-> 
-> New code:
-> 
-> ```c++
-> DynamicJsonDocument obj;
-> JsonObject& obj = doc.to<JsonObject>();
-> obj["key"] = "value";
-> serializeJson(doc, Serial);
-> ```
-
-v5.13.2
--------
-
-* Fixed `JsonBuffer::parse()` not respecting nesting limit correctly (issue #693)
-* Fixed inconsistencies in nesting level counting (PR #695 from Zhenyu Wu)
-* Fixed null values that could be pass to `strcmp()` (PR #745 from Mike Karlesky)
-* Added macros `ARDUINOJSON_VERSION`, `ARDUINOJSON_VERSION_MAJOR`...
-
-v5.13.1
--------
-
-* Fixed `JsonVariant::operator|(int)` that returned the default value if the variant contained a double (issue #675)
-* Allowed non-quoted key to contain underscores (issue #665)
-
-v5.13.0
--------
-
-* Changed the rules of string duplication (issue #658)
-* `RawJson()` accepts any kind of string and obeys to the same rules for duplication
-* Changed the return type of `strdup()` to `const char*` to prevent double duplication
-* Marked `strdup()` as deprecated
-
-> ### New rules for string duplication
->
-> | type                       | duplication |
-> |:---------------------------|:------------|
-> | const char*                | no          |
-> | char*                      | ~~no~~ yes  |
-> | String                     | yes         |
-> | std::string                | yes         |
-> | const __FlashStringHelper* | yes         |
->
-> These new rules make `JsonBuffer::strdup()` useless.
-
-v5.12.0
--------
-
-* Added `JsonVariant::operator|` to return a default value (see below)
-* Added a clear error message when compiled as C instead of C++ (issue #629)
-* Added detection of MPLAB XC compiler (issue #629)
-* Added detection of Keil ARM Compiler (issue #629)
-* Added an example that shows how to save and load a configuration file
-* Reworked all other examples
-
-> ### How to use the new feature?
->
-> If you have a block like this:
->
-> ```c++
-> const char* ssid = root["ssid"];
-> if (!ssid)
->   ssid = "default ssid";
-> ```
->
-> You can simplify like that:
->
-> ```c++
-> const char* ssid = root["ssid"] | "default ssid";
-> ```
-
-v5.11.2
--------
-
-* Fixed `DynamicJsonBuffer::clear()` not resetting allocation size (issue #561)
-* Fixed incorrect rounding for float values (issue #588)
-
-v5.11.1
--------
-
-* Removed dependency on `PGM_P` as Particle 0.6.2 doesn't define it (issue #546)
-* Fixed warning "dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]"
-* Fixed warning "floating constant exceeds range of 'float' [-Woverflow]" (issue #544)
-* Fixed warning "this statement may fall through" [-Wimplicit-fallthrough=] (issue #539)
-* Removed `ARDUINOJSON_DOUBLE_IS_64BITS` as it became useless.
-* Fixed too many decimals places in float serialization (issue #543)
-
-v5.11.0
--------
-
-* Made `JsonBuffer` non-copyable (PR #524 by @luisrayas3)
-* Added `StaticJsonBuffer::clear()`
-* Added `DynamicJsonBuffer::clear()`
-
-v5.10.1
--------
-
-* Fixed IntelliSense errors in Visual Micro (issue #483)
-* Fixed compilation in IAR Embedded Workbench (issue #515)
-* Fixed reading "true" as a float (issue #516)
-* Added `ARDUINOJSON_DOUBLE_IS_64BITS`
-* Added `ARDUINOJSON_EMBEDDED_MODE`
-
-v5.10.0
--------
-
-* Removed configurable number of decimal places (issues #288, #427 and #506)
-* Changed exponentiation thresholds to `1e7` and `1e-5` (issues #288, #427 and #506)
-* `JsonVariant::is<double>()` now returns `true` for integers
-* Fixed error `IsBaseOf is not a member of ArduinoJson::TypeTraits` (issue #495)
-* Fixed error `forming reference to reference` (issue #495)
-
-> ### BREAKING CHANGES :warning:
->
-> | Old syntax                      | New syntax          |
-> |:--------------------------------|:--------------------|
-> | `double_with_n_digits(3.14, 2)` | `3.14`              |
-> | `float_with_n_digits(3.14, 2)`  | `3.14f`             |
-> | `obj.set("key", 3.14, 2)`       | `obj["key"] = 3.14` |
-> | `arr.add(3.14, 2)`              | `arr.add(3.14)`     |
->
-> | Input     | Old output | New output |
-> |:----------|:-----------|:-----------|
-> | `3.14159` | `3.14`     | `3.14159`  |
-> | `42.0`    | `42.00`    | `42`       |
-> | `0.0`     | `0.00`     | `0`        |
->
-> | Expression                     | Old result | New result |
-> |:-------------------------------|:-----------|:-----------|
-> | `JsonVariant(42).is<int>()`    | `true`     | `true`     |
-> | `JsonVariant(42).is<float>()`  | `false`    | `true`     |
-> | `JsonVariant(42).is<double>()` | `false`    | `true`     |
-
-v5.9.0
-------
-
-* Added `JsonArray::remove(iterator)` (issue #479)
-* Added `JsonObject::remove(iterator)`
-* Renamed `JsonArray::removeAt(size_t)` into `remove(size_t)`
-* Renamed folder `include/` to `src/`
-* Fixed warnings `floating constant exceeds range of float`and `floating constant truncated to zero` (issue #483)
-* Removed `Print` class and converted `printTo()` to a template method (issue #276)
-* Removed example `IndentedPrintExample.ino`
-* Now compatible with Particle 0.6.1, thanks to Jacob Nite (issue #294 and PR #461 by @foodbag)
-
-v5.8.4
-------
-
-* Added custom implementation of `strtod()` (issue #453)
-* Added custom implementation of `strtol()` (issue #465)
-* `char` is now treated as an integral type (issue #337, #370)
-
-v5.8.3
-------
-
-* Fixed an access violation in `DynamicJsonBuffer` when memory allocation fails (issue #433)
-* Added operators `==` and `!=` for two `JsonVariant`s (issue #436)
-* Fixed `JsonVariant::operator[const FlashStringHelper*]` (issue #441)
-
-v5.8.2
-------
-
-* Fixed parsing of comments (issue #421)
-* Fixed ignored `Stream` timeout (issue #422)
-* Made sure we don't read more that necessary (issue #422)
-* Fixed error when the key of a `JsonObject` is a `char[]` (issue #423)
-* Reduced code size when using `const` references
-* Fixed error with string of type `unsigned char*` (issue #428)
-* Added `deprecated` attribute on `asArray()`, `asObject()` and `asString()` (issue #420)
-
-v5.8.1
-------
-
-* Fixed error when assigning a `volatile int` to a `JsonVariant` (issue #415)
-* Fixed errors with Variable Length Arrays (issue #416)
-* Fixed error when both `ARDUINOJSON_ENABLE_STD_STREAM` and `ARDUINOJSON_ENABLE_ARDUINO_STREAM` are set to `1`
-* Fixed error "Stream does not name a type" (issue #412)
-
-v5.8.0
-------
-
-* Added operator `==` to compare `JsonVariant` and strings (issue #402)
-* Added support for `Stream` (issue #300)
-* Reduced memory consumption by not duplicating spaces and comments
-
-> ### BREAKING CHANGES :warning:
->
-> `JsonBuffer::parseObject()` and  `JsonBuffer::parseArray()` have been pulled down to the derived classes `DynamicJsonBuffer` and `StaticJsonBufferBase`.
->
-> This means that if you have code like:
->
-> ```c++
-> void myFunction(JsonBuffer& jsonBuffer);
-> ```
->
-> you need to replace it with one of the following:
->
-> ```c++
-> void myFunction(DynamicJsonBuffer& jsonBuffer);
-> void myFunction(StaticJsonBufferBase& jsonBuffer);
-> template<typename TJsonBuffer> void myFunction(TJsonBuffer& jsonBuffer);
-> ```
-
-v5.7.3
-------
-
-* Added an `printTo(char[N])` and `prettyPrintTo(char[N])` (issue #292)
-* Added ability to set a nested value like this: `root["A"]["B"] = "C"` (issue #352)
-* Renamed `*.ipp` to `*Impl.hpp` because they were ignored by Arduino IDE (issue #396)
-
-v5.7.2
-------
-
-* Made PROGMEM available on more platforms (issue #381)
-* Fixed PROGMEM causing an exception on ESP8266 (issue #383)
-
-v5.7.1
-------
-
-* Added support for PROGMEM (issue #76)
-* Fixed compilation error when index is not an `int` (issue #381)
-
-v5.7.0
-------
-
-* Templatized all functions using `String` or `std::string`
-* Removed `ArduinoJson::String`
-* Removed `JsonVariant::defaultValue<T>()`
-* Removed non-template `JsonObject::get()` and `JsonArray.get()`
-* Fixed support for `StringSumHelper` (issue #184)
-* Replaced `ARDUINOJSON_USE_ARDUINO_STRING` by `ARDUINOJSON_ENABLE_STD_STRING` and `ARDUINOJSON_ENABLE_ARDUINO_STRING` (issue #378)
-* Added example `StringExample.ino` to show where `String` can be used
-* Increased default nesting limit to 50 when compiled for a computer (issue #349)
-
-> ### BREAKING CHANGES :warning:
->
-> The non-template functions `JsonObject::get()` and `JsonArray.get()` have been removed. This means that you need to explicitely tell the type you expect in return.
->
-> Old code:
->
-> ```c++
-> #define ARDUINOJSON_USE_ARDUINO_STRING 0
-> JsonVariant value1 = myObject.get("myKey");
-> JsonVariant value2 = myArray.get(0);
-> ```
->
-> New code:
->
-> ```c++
-> #define ARDUINOJSON_ENABLE_ARDUINO_STRING 0
-> #define ARDUINOJSON_ENABLE_STD_STRING 1
-> JsonVariant value1 = myObject.get<JsonVariant>("myKey");
-> JsonVariant value2 = myArray.get<JsonVariant>(0);
-> ```
-
-v5.6.7
-------
-
-* Fixed `array[idx].as<JsonVariant>()` and `object[key].as<JsonVariant>()`
-* Fixed return value of `JsonObject::set()` (issue #350)
-* Fixed undefined behavior in `Prettyfier` and `Print` (issue #354)
-* Fixed parser that incorrectly rejected floats containing a `+` (issue #349)
-
-v5.6.6
-------
-
-* Fixed `-Wparentheses` warning introduced in v5.6.5 (PR #335 by @nuket)
-* Added `.mbedignore` for ARM mbdeb (PR #334 by @nuket)
-* Fixed  `JsonVariant::success()` which didn't propagate `JsonArray::success()` nor `JsonObject::success()` (issue #342).
-
-v5.6.5
-------
-
-* `as<char*>()` now returns `true` when input is `null` (issue #330)
-
-v5.6.4
-------
-
-* Fixed error in float serialization (issue #324)
-
-v5.6.3
-------
-
-* Improved speed of float serialization (about twice faster)
-* Added `as<JsonArray>()` as a synonym for `as<JsonArray&>()`... (issue #291)
-* Fixed `call of overloaded isinf(double&) is ambiguous` (issue #284)
-
-v5.6.2
-------
-
-* Fixed build when another lib does `#undef isnan` (issue #284)
-
-v5.6.1
-------
-
-* Added missing `#pragma once` (issue #310)
-
-v5.6.0
-------
-
-* ArduinoJson is now a header-only library (issue #199)
-
-v5.5.1
-------
-
-* Fixed compilation error with Intel Galileo (issue #299)
-
-v5.5.0
-------
-
-* Added `JsonVariant::success()` (issue #279)
-* Renamed `JsonVariant::invalid<T>()` to `JsonVariant::defaultValue<T>()`
-
-v5.4.0
-------
-
-* Changed `::String` to `ArduinoJson::String` (issue #275)
-* Changed `::Print` to `ArduinoJson::Print` too
-
-v5.3.0
-------
-
-* Added custom implementation of `ftoa` (issues #266, #267, #269 and #270)
-* Added `JsonVariant JsonBuffer::parse()` (issue #265)
-* Fixed `unsigned long` printed as `signed long` (issue #170)
-
-v5.2.0
-------
-
-* Added `JsonVariant::as<char*>()` as a synonym for `JsonVariant::as<const char*>()` (issue #257)
-* Added example `JsonHttpClient` (issue #256)
-* Added `JsonArray::copyTo()` and `JsonArray::copyFrom()` (issue #254)
-* Added `RawJson()` to insert pregenerated JSON portions (issue #259)
-
-v5.1.1
-------
-
-* Removed `String` duplication when one replaces a value in a `JsonObject` (PR #232 by @ulion)
-
-v5.1.0
-------
-
-* Added support of `long long` (issue #171)
-* Moved all build settings to `ArduinoJson/Configuration.hpp`
-
-> ### BREAKING CHANGE :warning:
->
-> If you defined `ARDUINOJSON_ENABLE_STD_STREAM`, you now need to define it to `1`.
-
-v5.0.8
-------
-
-* Made the library compatible with [PlatformIO](http://platformio.org/) (issue #181)
-* Fixed `JsonVariant::is<bool>()` that was incorrectly returning false (issue #214)
-
-v5.0.7
-------
-
-* Made library easier to use from a CMake project: simply `add_subdirectory(ArduinoJson/src)`
-* Changed `String` to be a `typedef` of `std::string` (issues #142 and #161)
-
-> ### BREAKING CHANGES :warning:
->
-> - `JsonVariant(true).as<String>()` now returns `"true"` instead of `"1"`
-> - `JsonVariant(false).as<String>()` now returns `"false"` instead of `"0"`
-
-v5.0.6
-------
-
-* Added parameter to `DynamicJsonBuffer` constructor to set initial size (issue #152)
-* Fixed warning about library category in Arduino 1.6.6 (issue #147)
-* Examples: Added a loop to wait for serial port to be ready (issue #156)
-
-v5.0.5
-------
-
-* Added overload `JsonObjectSuscript::set(value, decimals)` (issue #143)
-* Use `float` instead of `double` to reduce the size of `JsonVariant` (issue #134)
-
-v5.0.4
-------
-
-* Fixed ambiguous overload with `JsonArraySubscript` and `JsonObjectSubscript` (issue #122)
-
-v5.0.3
-------
-
-* Fixed `printTo(String)` which wrote numbers instead of strings (issue #120)
-* Fixed return type of `JsonArray::is<T>()` and some others (issue #121)
-
-v5.0.2
-------
-
-* Fixed segmentation fault in `parseObject(String)` and `parseArray(String)`, when the
-  `StaticJsonBuffer` is too small to hold a copy of the string
-* Fixed Clang warning "register specifier is deprecated" (issue #102)
-* Fixed GCC warning "declaration shadows a member" (issue #103)
-* Fixed memory alignment, which made ESP8266 crash (issue #104)
-* Fixed compilation on Visual Studio 2010 and 2012 (issue #107)
-
-v5.0.1
-------
-
-* Fixed compilation with Arduino 1.0.6 (issue #99)
-
-v5.0.0
-------
-
-* Added support of `String` class (issues #55, #56, #70, #77)
-* Added `JsonBuffer::strdup()` to make a copy of a string (issues #10, #57)
-* Implicitly call `strdup()` for `String` but not for `char*` (issues #84, #87)
-* Added support of non standard JSON input (issue #44)
-* Added support of comments in JSON input (issue #88)
-* Added implicit cast between numerical types (issues #64, #69, #93)
-* Added ability to read number values as string (issue #90)
-* Redesigned `JsonVariant` to leverage converting constructors instead of assignment operators (issue #66)
-* Switched to new the library layout (requires Arduino 1.0.6 or above)
-
-> ### BREAKING CHANGES :warning:
->
-> - `JsonObject::add()` was renamed to `set()`
-> - `JsonArray::at()` and `JsonObject::at()` were renamed to `get()`
-> - Number of digits of floating point value are now set with `double_with_n_digits()`
-
-**Personal note about the `String` class**:
-Support of the `String` class has been added to the library because many people use it in their programs.
-However, you should not see this as an invitation to use the `String` class.
-The `String` class is **bad** because it uses dynamic memory allocation.
-Compared to static allocation, it compiles to a bigger, slower program, and is less predictable.
-You certainly don't want that in an embedded environment!
+HEAD
+----
+
+* Remove `BasicJsonDocument`
+* Remove `StaticJsonDocument`
+* Add abstract `Allocator` class
+* Merge `DynamicJsonDocument` with `JsonDocument`
+* Remove `JSON_ARRAY_SIZE()`, `JSON_OBJECT_SIZE()`, and `JSON_STRING_SIZE()`
+* Remove `ARDUINOJSON_ENABLE_STRING_DEDUPLICATION` (string deduplication cannot be enabled anymore)
+* Remove `JsonDocument::capacity()`
+* Store the strings in the heap
+* Reference-count shared strings
+* Always store `serialized("string")` by copy (#1915)
+* Remove the zero-copy mode of `deserializeJson()` and `deserializeMsgPack()`

CMakeLists.txt

@@ -1,21 +1,25 @@
-# ArduinoJson - arduinojson.org
-# Copyright Benoit Blanchon 2014-2020
+# ArduinoJson - https://arduinojson.org
+# Copyright © 2014-2023, Benoit BLANCHON
 # MIT License
 
-cmake_minimum_required(VERSION 3.0)
-project(ArduinoJson)
+cmake_minimum_required(VERSION 3.15)
 
-enable_testing()
-
-add_definitions(-DARDUINOJSON_DEBUG)
-if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
-	add_compile_options(-g -O0)
+if(ESP_PLATFORM)
+	# Build ArduinoJson as an ESP-IDF component
+	idf_component_register(INCLUDE_DIRS src)
+	return()
 endif()
 
-if(${COVERAGE})
-	set(CMAKE_CXX_FLAGS "-fprofile-arcs -ftest-coverage")
+project(ArduinoJson VERSION 7.0.0)
+
+if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
+	include(CTest)
 endif()
 
-include_directories(${CMAKE_CURRENT_LIST_DIR}/src)
-add_subdirectory(extras/tests)
-add_subdirectory(extras/fuzzing)
+add_subdirectory(src)
+
+if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_TESTING)
+	include(extras/CompileOptions.cmake)
+	add_subdirectory(extras/tests)
+	add_subdirectory(extras/fuzzing)
+endif()

CONTRIBUTING.md

@@ -6,6 +6,5 @@ You can submit changes via GitHub Pull Requests.
 
 Please:
 
-1. Unit test every change in behavior
+1. Update the test suite for any change of behavior
 2. Use clang-format in "file" mode to format the code
-3. Consider using the Continuous Integration (Travis and AppVeyor)

LICENSE.txt

@@ -1,10 +1,10 @@
-The MIT License (MIT)
----------------------
-
-Copyright © 2014-2019 Benoit BLANCHON
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+The MIT License (MIT)
+---------------------
+
+Copyright © 2014-2023, Benoit BLANCHON
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,13 +1,15 @@
-![ArduinoJson](banner.svg)
+<p align="center">
+  <a href="https://arduinojson.org/"><img alt="ArduinoJson" src="https://arduinojson.org/images/logo.svg" width="200" /></a>
+</p>
 
 ---
 
-[![arduino-library-badge](https://www.ardu-badge.com/badge/ArduinoJson.svg?version=6.14.1)](https://www.ardu-badge.com/ArduinoJson/6.14.1)
-[![Build Status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/6.x?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/6.x)
-[![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=6.x)](https://travis-ci.org/bblanchon/ArduinoJson)
+[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/bblanchon/ArduinoJson/ci.yml?branch=7.x&logo=github)](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22+branch%3A7.x)
+[![Continuous Integration](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/7.x?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/7.x)
 [![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/arduinojson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:arduinojson)
-[![Coverage Status](https://coveralls.io/repos/github/bblanchon/ArduinoJson/badge.svg?branch=6.x)](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x)
-[![GitHub stars](https://img.shields.io/github/stars/bblanchon/ArduinoJson?style=flat)](https://github.com/bblanchon/ArduinoJson/stargazers)
+[![Coveralls branch](https://img.shields.io/coveralls/github/bblanchon/ArduinoJson/7.x?logo=coveralls)](https://coveralls.io/github/bblanchon/ArduinoJson?branch=7.x)  
+[![GitHub stars](https://img.shields.io/github/stars/bblanchon/ArduinoJson?style=flat&logo=github&color=orange)](https://github.com/bblanchon/ArduinoJson/stargazers)
+[![GitHub Sponsors](https://img.shields.io/github/sponsors/bblanchon?logo=github&color=orange)](https://github.com/sponsors/bblanchon)
 
 ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).
 
@@ -17,8 +19,9 @@ ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).
     * [Optionally decodes UTF-16 escape sequences to UTF-8](https://arduinojson.org/v6/api/config/decode_unicode/)
     * [Optionally stores links to the input buffer (zero-copy)](https://arduinojson.org/v6/api/json/deserializejson/)
     * [Optionally supports comments in the input](https://arduinojson.org/v6/api/config/enable_comments/)
+    * [Optionally filters the input to keep only desired values](https://arduinojson.org/v6/api/json/deserializejson/#filtering)
     * Supports single quotes as a string delimiter
-    * Compatible with NDJSON and JSON Lines
+    * Compatible with [NDJSON](http://ndjson.org/) and [JSON Lines](https://jsonlines.org/)
 * [JSON serialization](https://arduinojson.org/v6/api/json/serializejson/)
     * [Can write to a buffer or a stream](https://arduinojson.org/v6/api/json/serializejson/)
     * [Optionally indents the document (prettified JSON)](https://arduinojson.org/v6/api/json/serializejsonpretty/)
@@ -28,25 +31,28 @@ ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).
     * [Twice smaller than the "official" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/)
     * [Almost 10% faster than the "official" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/)
     * [Consumes roughly 10% less RAM than the "official" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/)
-    * [Fixed memory allocation, no heap fragmentation](https://arduinojson.org/v6/api/jsondocument/)
-    * [Optionally works without heap memory (zero malloc)](https://arduinojson.org/v6/api/staticjsondocument/)
+    * [Deduplicates strings](https://arduinojson.org/news/2020/08/01/version-6-16-0/)
 * Versatile
-    * [Supports custom allocators (to use external RAM chip, for example)](https://arduinojson.org/v6/how-to/use-external-ram-on-esp32/)
-    * Supports [Arduino's `String`](https://arduinojson.org/v6/api/config/enable_arduino_string/) and [STL's `std::string`](https://arduinojson.org/v6/api/config/enable_std_string/)
-    * Supports Arduino's `Stream` and [STL's `std::istream`/`std::ostream`](https://arduinojson.org/v6/api/config/enable_std_stream/)
-    * [Supports Flash strings](https://arduinojson.org/v6/api/config/enable_progmem/)
+    * Supports [custom allocators (to use external RAM chip, for example)](https://arduinojson.org/v6/how-to/use-external-ram-on-esp32/)
+    * Supports [`String`](https://arduinojson.org/v6/api/config/enable_arduino_string/), [`std::string`](https://arduinojson.org/v6/api/config/enable_std_string/), and [`std::string_view`](https://arduinojson.org/v6/api/config/enable_string_view/)
+    * Supports [`Stream`](https://arduinojson.org/v6/api/config/enable_arduino_stream/) and [`std::istream`/`std::ostream`](https://arduinojson.org/v6/api/config/enable_std_stream/)
+    * Supports [Flash strings](https://arduinojson.org/v6/api/config/enable_progmem/)
+    * Supports [custom readers](https://arduinojson.org/v6/api/json/deserializejson/#custom-reader) and [custom writers](https://arduinojson.org/v6/api/json/serializejson/#custom-writer)
+    * Supports [custom converters](https://arduinojson.org/news/2021/05/04/version-6-18-0/)
 * Portable
     * Usable on any C++ project (not limited to Arduino)
-    * Compatible with C++98
+    * Compatible with C++11, C++14 and C++17
+    * Support for C++98/C++03 available on [ArduinoJson 6.20.x](https://github.com/bblanchon/ArduinoJson/tree/6.20.x)
     * Zero warnings with `-Wall -Wextra -pedantic` and `/W4`
     * [Header-only library](https://en.wikipedia.org/wiki/Header-only)
     * Works with virtually any board
         * Arduino boards: [Uno](https://amzn.to/38aL2ik), [Due](https://amzn.to/36YkWi2), [Micro](https://amzn.to/35WkdwG), [Nano](https://amzn.to/2QTvwRX), [Mega](https://amzn.to/36XWhuf), [Yun](https://amzn.to/30odURc), [Leonardo](https://amzn.to/36XWjlR)...
         * Espressif chips: [ESP8266](https://amzn.to/36YluV8), [ESP32](https://amzn.to/2G4pRCB)
         * Lolin (WeMos) boards: [D1 mini](https://amzn.to/2QUpz7q), [D1 Mini Pro](https://amzn.to/36UsGSs)...
-        * Teensy boards: [4.0](https://amzn.to/30ljXGq), [3.2](https://amzn.to/2FT0EuC), [2.0](https://amzn.to/2QXUMXj) 
+        * Teensy boards: [4.0](https://amzn.to/30ljXGq), [3.2](https://amzn.to/2FT0EuC), [2.0](https://amzn.to/2QXUMXj)
         * Particle boards: [Argon](https://amzn.to/2FQHa9X), [Boron](https://amzn.to/36WgLUd), [Electron](https://amzn.to/30vEc4k), [Photon](https://amzn.to/387F9Cd)...
         * Texas Instruments boards: [MSP430](https://amzn.to/30nJWgg)...
+        * Soft cores: [Nios II](https://en.wikipedia.org/wiki/Nios_II)...
     * Tested on all major development environments
         * [Arduino IDE](https://www.arduino.cc/en/Main/Software)
         * [Atmel Studio](http://www.atmel.com/microsite/atmel-studio/)
@@ -55,33 +61,39 @@ ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).
         * [IAR Embedded Workbench](https://www.iar.com/iar-embedded-workbench/)
         * [Keil uVision](http://www.keil.com/)
         * [MPLAB X IDE](http://www.microchip.com/mplab/mplab-x-ide)
+        * [Particle](https://www.particle.io/)
         * [PlatformIO](http://platformio.org/)
         * [Sloeber plugin for Eclipse](https://eclipse.baeyens.it/)
         * [Visual Micro](http://www.visualmicro.com/)
         * [Visual Studio](https://www.visualstudio.com/)
-    * [Even works with online compilers like wandbox.org](https://wandbox.org/permlink/t7KP7I6dVuLhqzDl)
+    * [Even works with online compilers like wandbox.org](https://wandbox.org/permlink/RlZSKy17DjJ6HcdN)
+    * [CMake friendly](https://arduinojson.org/v6/how-to/use-arduinojson-with-cmake/)
 * Well designed
-    * [Elegant API](http://127.0.0.1:4000/v6/example/)
+    * [Elegant API](http://arduinojson.org/v6/example/)
     * [Thread-safe](https://en.wikipedia.org/wiki/Thread_safety)
     * Self-contained (no external dependency)
     * `const` friendly
-    * `for` friendly
+    * [`for` friendly](https://arduinojson.org/v6/api/jsonobject/begin_end/)
     * [TMP friendly](https://en.wikipedia.org/wiki/Template_metaprogramming)
+    * Handles [integer overflows](https://arduinojson.org/v6/api/jsonvariant/as/#integer-overflows)
 * Well tested
-    * [Unit test coverage close to 100%](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x)
+    * [Unit test coverage close to 100%](https://coveralls.io/github/bblanchon/ArduinoJson?branch=7.x)
     * Continuously tested on
-        * [Visual Studio 2010, 2012, 2013, 2015, 2017, 2019](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/6.x)
-        * [GCC 4.4, 4.6, 4.7, 4.8, 4.9, 5, 6, 7, 8](https://travis-ci.org/bblanchon/ArduinoJson)
-        * [Clang 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 5.0, 6.0, 7, 8](https://travis-ci.org/bblanchon/ArduinoJson)
+        * [Visual Studio 2017, 2019, 2022](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/7.x)
+        * [GCC 5, 6, 7, 8, 9, 10, 11](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22)
+        * [Clang 3.8, 3.9, 4.0, 5.0, 6.0, 7, 8, 9, 10](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22)
     * [Continuously fuzzed with Google OSS Fuzz](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:arduinojson)
+    * Passes all default checks of [clang-tidy](https://releases.llvm.org/10.0.0/tools/clang/tools/extra/docs/clang-tidy/)
 * Well documented
     * [Tutorials](https://arduinojson.org/v6/doc/deserialization/)
     * [Examples](https://arduinojson.org/v6/example/)
     * [How-tos](https://arduinojson.org/v6/example/)
     * [FAQ](https://arduinojson.org/v6/faq/)
+    * [Troubleshooter](https://arduinojson.org/v6/troubleshooter/)
     * [Book](https://arduinojson.org/book/)
+    * [Changelog](CHANGELOG.md)
 * Vibrant user community
-    * Most popular of all Arduino libraries on [GitHub](https://github.com/search?o=desc&q=arduino+library&s=stars&type=Repositories) and [PlatformIO](https://platformio.org/lib/search)
+    * Most popular of all Arduino libraries on [GitHub](https://github.com/search?o=desc&q=arduino+library&s=stars&type=Repositories)
     * [Used in hundreds of projects](https://www.hackster.io/search?i=projects&q=arduinojson)
     * [Responsive support](https://github.com/bblanchon/ArduinoJson/issues?q=is%3Aissue+is%3Aclosed)
 
@@ -94,7 +106,7 @@ Here is a program that parses a JSON document with ArduinoJson.
 ```c++
 char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-DynamicJsonDocument doc(1024);
+JsonDocument doc(1024);
 deserializeJson(doc, json);
 
 const char* sensor = doc["sensor"];
@@ -103,32 +115,42 @@ double latitude    = doc["data"][0];
 double longitude   = doc["data"][1];
 ```
 
-See the [tutorial on arduinojson.org](https://arduinojson.org/doc/decoding/?utm_source=github&utm_medium=readme)
+See the [tutorial on arduinojson.org](https://arduinojson.org/v6/doc/deserialization/)
 
 ### Serialization
 
 Here is a program that generates a JSON document with ArduinoJson:
 
 ```c++
-DynamicJsonDocument doc(1024);
+JsonDocument doc(1024);
 
 doc["sensor"] = "gps";
 doc["time"]   = 1351824120;
-
-JsonArray data = doc.createNestedArray("data");
-data.add(48.756080);
-data.add(2.302038);
+doc["data"][0] = 48.756080;
+doc["data"][1] = 2.302038;
 
 serializeJson(doc, Serial);
 // This prints:
 // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
 ```
 
-See the [tutorial on arduinojson.org](https://arduinojson.org/doc/encoding/?utm_source=github&utm_medium=readme)
+See the [tutorial on arduinojson.org](https://arduinojson.org/v6/doc/serialization/)
 
-## Support the project
+## Sponsors
 
-Do you like this library? Please [star this project on GitHub](https://github.com/bblanchon/ArduinoJson/stargazers)!
+ArduinoJson is thankful to its sponsors. Please give them a visit; they deserve it!
 
-What? You don't like it but you *love* it?
-We don't take donations anymore, but [we sell a book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme), so you can help and learn at the same time!
+<p>
+  <a href="https://www.programmingelectronics.com/" rel="sponsored">
+    <img src="https://arduinojson.org/images/2021/10/programmingeleactronicsacademy.png" alt="Programming Electronics Academy" width="200">
+  </a>
+</p>
+<p>
+  <a href="https://github.com/1technophile" rel="sponsored">
+    <img alt="1technophile" src="https://avatars.githubusercontent.com/u/12672732?s=40&v=4">
+  </a>
+</p>
+
+If you run a commercial project that embeds ArduinoJson, think about [sponsoring the library's development](https://github.com/sponsors/bblanchon): it ensures the code that your products rely on stays actively maintained. It can also give your project some exposure to the makers' community.
+
+If you are an individual user and want to support the development (or give a sign of appreciation), consider purchasing the book [Mastering ArduinoJson](https://arduinojson.org/book/)&nbsp;❤, or simply [cast a star](https://github.com/bblanchon/ArduinoJson/stargazers)&nbsp;⭐.

appveyor.yml

@@ -1,22 +1,28 @@
-version: 6.14.1.{build}
+version: 7.0.0.{build}
 environment:
   matrix:
-  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-    CMAKE_GENERATOR: Visual Studio 16 2019
-  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-    CMAKE_GENERATOR: Visual Studio 15 2017
-  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-    CMAKE_GENERATOR: Visual Studio 14 2015
-  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-    CMAKE_GENERATOR: Visual Studio 12 2013
-  - CMAKE_GENERATOR: Visual Studio 11 2012
-  - CMAKE_GENERATOR: Visual Studio 10 2010
-  - CMAKE_GENERATOR: MinGW Makefiles
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
+      CMAKE_GENERATOR: Visual Studio 17 2022
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      CMAKE_GENERATOR: Visual Studio 16 2019
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      CMAKE_GENERATOR: Visual Studio 15 2017
+    - CMAKE_GENERATOR: Ninja
+      MINGW32: i686-6.3.0-posix-dwarf-rt_v5-rev1 # MinGW-w64 6.3.0 i686
+    - CMAKE_GENERATOR: Ninja
+      MINGW64: x86_64-6.3.0-posix-seh-rt_v5-rev1 # MinGW-w64 6.3.0 x86_64
+    - CMAKE_GENERATOR: Ninja
+      MINGW64: x86_64-7.3.0-posix-seh-rt_v5-rev0 # MinGW-w64 7.3.0 x86_64
+    - CMAKE_GENERATOR: Ninja
+      MINGW64: x86_64-8.1.0-posix-seh-rt_v6-rev0 # MinGW-w64 8.1.0 x86_64
 configuration: Debug
 before_build:
-- set PATH=C:\MinGW\bin;%PATH:C:\Program Files\Git\usr\bin;=% # Workaround for CMake not wanting sh.exe on PATH for MinGW
-- cmake -DCMAKE_BUILD_TYPE=%CONFIGURATION% -G "%CMAKE_GENERATOR%" .
+  - set PATH=%PATH:C:\Program Files\Git\usr\bin;=% # Workaround for CMake not wanting sh.exe on PATH for MinGW
+  - if defined MINGW set PATH=C:\%MINGW%\bin;%PATH%
+  - if defined MINGW32 set PATH=C:\mingw-w64\%MINGW32%\mingw32\bin;%PATH%
+  - if defined MINGW64 set PATH=C:\mingw-w64\%MINGW64%\mingw64\bin;%PATH%
+  - cmake -DCMAKE_BUILD_TYPE=%CONFIGURATION% -G "%CMAKE_GENERATOR%" .
 build_script:
-- cmake --build . --config %CONFIGURATION%
+  - cmake --build . --config %CONFIGURATION%
 test_script:
-- ctest -C %CONFIGURATION% --output-on-failure .
+  - ctest -C %CONFIGURATION% --output-on-failure .

examples/JsonConfigFile/JsonConfigFile.ino

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 //
 // This example shows how to store your project configuration in a file.
@@ -34,18 +34,18 @@ struct Config {
   int port;
 };
 
-const char *filename = "/config.txt";  // <- SD library uses 8.3 filenames
+const char* filename = "/config.txt";  // <- SD library uses 8.3 filenames
 Config config;                         // <- global configuration object
 
 // Loads the configuration from a file
-void loadConfiguration(const char *filename, Config &config) {
+void loadConfiguration(const char* filename, Config& config) {
   // Open file for reading
   File file = SD.open(filename);
 
   // Allocate a temporary JsonDocument
   // Don't forget to change the capacity to match your requirements.
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<512> doc;
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  JsonDocument doc(512);
 
   // Deserialize the JSON document
   DeserializationError error = deserializeJson(doc, file);
@@ -63,7 +63,7 @@ void loadConfiguration(const char *filename, Config &config) {
 }
 
 // Saves the configuration to a file
-void saveConfiguration(const char *filename, const Config &config) {
+void saveConfiguration(const char* filename, const Config& config) {
   // Delete existing file, otherwise the configuration is appended to the file
   SD.remove(filename);
 
@@ -76,8 +76,8 @@ void saveConfiguration(const char *filename, const Config &config) {
 
   // Allocate a temporary JsonDocument
   // Don't forget to change the capacity to match your requirements.
-  // Use arduinojson.org/assistant to compute the capacity.
-  StaticJsonDocument<256> doc;
+  // Use https://arduinojson.org/assistant to compute the capacity.
+  JsonDocument doc(256);
 
   // Set the values in the document
   doc["hostname"] = config.hostname;
@@ -93,7 +93,7 @@ void saveConfiguration(const char *filename, const Config &config) {
 }
 
 // Prints the content of a file to the Serial
-void printFile(const char *filename) {
+void printFile(const char* filename) {
   // Open file for reading
   File file = SD.open(filename);
   if (!file) {
@@ -114,7 +114,8 @@ void printFile(const char *filename) {
 void setup() {
   // Initialize serial port
   Serial.begin(9600);
-  while (!Serial) continue;
+  while (!Serial)
+    continue;
 
   // Initialize SD library
   const int chipSelect = 4;
@@ -140,6 +141,12 @@ void loop() {
   // not used in this example
 }
 
+// Performance issue?
+// ------------------
+//
+// File is an unbuffered stream, which is not optimal for ArduinoJson.
+// See: https://arduinojson.org/v6/how-to/improve-speed/
+
 // See also
 // --------
 //

examples/JsonFilterExample/JsonFilterExample.ino

@@ -0,0 +1,64 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+//
+// This example shows how to use DeserializationOption::Filter
+//
+// https://arduinojson.org/v6/example/filter/
+
+#include <ArduinoJson.h>
+
+void setup() {
+  // Initialize serial port
+  Serial.begin(9600);
+  while (!Serial)
+    continue;
+
+  // The huge input: an extract from OpenWeatherMap response
+  auto input_json = F(
+      "{\"cod\":\"200\",\"message\":0,\"list\":[{\"dt\":1581498000,\"main\":{"
+      "\"temp\":3.23,\"feels_like\":-3.63,\"temp_min\":3.23,\"temp_max\":4.62,"
+      "\"pressure\":1014,\"sea_level\":1014,\"grnd_level\":1010,\"humidity\":"
+      "58,\"temp_kf\":-1.39},\"weather\":[{\"id\":800,\"main\":\"Clear\","
+      "\"description\":\"clear "
+      "sky\",\"icon\":\"01d\"}],\"clouds\":{\"all\":0},\"wind\":{\"speed\":6."
+      "19,\"deg\":266},\"sys\":{\"pod\":\"d\"},\"dt_txt\":\"2020-02-12 "
+      "09:00:00\"},{\"dt\":1581508800,\"main\":{\"temp\":6.09,\"feels_like\":-"
+      "1.07,\"temp_min\":6.09,\"temp_max\":7.13,\"pressure\":1015,\"sea_"
+      "level\":1015,\"grnd_level\":1011,\"humidity\":48,\"temp_kf\":-1.04},"
+      "\"weather\":[{\"id\":800,\"main\":\"Clear\",\"description\":\"clear "
+      "sky\",\"icon\":\"01d\"}],\"clouds\":{\"all\":9},\"wind\":{\"speed\":6."
+      "64,\"deg\":268},\"sys\":{\"pod\":\"d\"},\"dt_txt\":\"2020-02-12 "
+      "12:00:00\"}],\"city\":{\"id\":2643743,\"name\":\"London\",\"coord\":{"
+      "\"lat\":51.5085,\"lon\":-0.1257},\"country\":\"GB\",\"population\":"
+      "1000000,\"timezone\":0,\"sunrise\":1581492085,\"sunset\":1581527294}}");
+
+  // The filter: it contains "true" for each value we want to keep
+  JsonDocument filter(200);
+  filter["list"][0]["dt"] = true;
+  filter["list"][0]["main"]["temp"] = true;
+
+  // Deserialize the document
+  JsonDocument doc(400);
+  deserializeJson(doc, input_json, DeserializationOption::Filter(filter));
+
+  // Print the result
+  serializeJsonPretty(doc, Serial);
+}
+
+void loop() {
+  // not used in this example
+}
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// deserialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on deserialization.
+// It begins with a simple example, like the one above, and then adds more
+// features like deserializing directly from a file or an HTTP request.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 //
 // This example shows how to generate a JSON document with ArduinoJson.
@@ -11,19 +11,15 @@
 void setup() {
   // Initialize Serial port
   Serial.begin(9600);
-  while (!Serial) continue;
+  while (!Serial)
+    continue;
 
   // Allocate the JSON document
   //
-  // Inside the brackets, 200 is the RAM allocated to this document.
+  // Inside the parentheses, 200 is the RAM allocated to this document.
   // Don't forget to change this value to match your requirement.
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<200> doc;
-
-  // StaticJsonObject allocates memory on the stack, it can be
-  // replaced by DynamicJsonDocument which allocates in the heap.
-  //
-  // DynamicJsonDocument  doc(200);
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  JsonDocument doc(200);
 
   // Add values in the document
   //

examples/JsonHttpClient/JsonHttpClient.ino

@@ -1,11 +1,11 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 //
 // This example shows how to parse a JSON document in an HTTP response.
 // It uses the Ethernet library, but can be easily adapted for Wifi.
 //
-// It performs a GET resquest on arduinojson.org/example.json
+// It performs a GET resquest on https://arduinojson.org/example.json
 // Here is the expected response:
 // {
 //   "sensor": "gps",
@@ -53,6 +53,7 @@ void setup() {
   client.println(F("Connection: close"));
   if (client.println() == 0) {
     Serial.println(F("Failed to send request"));
+    client.stop();
     return;
   }
 
@@ -63,6 +64,7 @@ void setup() {
   if (strcmp(status + 9, "200 OK") != 0) {
     Serial.print(F("Unexpected response: "));
     Serial.println(status);
+    client.stop();
     return;
   }
 
@@ -70,25 +72,26 @@ void setup() {
   char endOfHeaders[] = "\r\n\r\n";
   if (!client.find(endOfHeaders)) {
     Serial.println(F("Invalid response"));
+    client.stop();
     return;
   }
 
   // Allocate the JSON document
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  const size_t capacity = JSON_OBJECT_SIZE(3) + JSON_ARRAY_SIZE(2) + 60;
-  DynamicJsonDocument doc(capacity);
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  JsonDocument doc(256);
 
   // Parse JSON object
   DeserializationError error = deserializeJson(doc, client);
   if (error) {
     Serial.print(F("deserializeJson() failed: "));
-    Serial.println(error.c_str());
+    Serial.println(error.f_str());
+    client.stop();
     return;
   }
 
   // Extract values
   Serial.println(F("Response:"));
-  Serial.println(doc["sensor"].as<char*>());
+  Serial.println(doc["sensor"].as<const char*>());
   Serial.println(doc["time"].as<long>());
   Serial.println(doc["data"][0].as<float>(), 6);
   Serial.println(doc["data"][1].as<float>(), 6);
@@ -101,6 +104,12 @@ void loop() {
   // not used in this example
 }
 
+// Performance issue?
+// ------------------
+//
+// EthernetClient is an unbuffered stream, which is not optimal for ArduinoJson.
+// See: https://arduinojson.org/v6/how-to/improve-speed/
+
 // See also
 // --------
 //

examples/JsonParserExample/JsonParserExample.ino

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 //
 // This example shows how to deserialize a JSON document with ArduinoJson.
@@ -11,19 +11,15 @@
 void setup() {
   // Initialize serial port
   Serial.begin(9600);
-  while (!Serial) continue;
+  while (!Serial)
+    continue;
 
   // Allocate the JSON document
   //
-  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
+  // Inside the parentheses, 200 is the capacity of the memory pool in bytes.
   // Don't forget to change this value to match your JSON document.
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<200> doc;
-
-  // StaticJsonDocument<N> allocates memory on the stack, it can be
-  // replaced by DynamicJsonDocument which allocates in the heap.
-  //
-  // DynamicJsonDocument doc(200);
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  JsonDocument doc(200);
 
   // JSON input string.
   //
@@ -42,7 +38,7 @@ void setup() {
   // Test if parsing succeeds.
   if (error) {
     Serial.print(F("deserializeJson() failed: "));
-    Serial.println(error.c_str());
+    Serial.println(error.f_str());
     return;
   }
 

examples/JsonServer/JsonServer.ino

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 //
 // This example shows how to implement an HTTP server that sends a JSON document
@@ -25,7 +25,8 @@ EthernetServer server(80);
 void setup() {
   // Initialize serial port
   Serial.begin(9600);
-  while (!Serial) continue;
+  while (!Serial)
+    continue;
 
   // Initialize Ethernet libary
   if (!Ethernet.begin(mac)) {
@@ -46,16 +47,18 @@ void loop() {
   EthernetClient client = server.available();
 
   // Do we have a client?
-  if (!client) return;
+  if (!client)
+    return;
 
   Serial.println(F("New client"));
 
   // Read the request (we ignore the content in this example)
-  while (client.available()) client.read();
+  while (client.available())
+    client.read();
 
   // Allocate a temporary JsonDocument
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<500> doc;
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  JsonDocument doc(500);
 
   // Create the "analog" array
   JsonArray analogValues = doc.createNestedArray("analog");
@@ -96,6 +99,12 @@ void loop() {
   client.stop();
 }
 
+// Performance issue?
+// ------------------
+//
+// EthernetClient is an unbuffered stream, which is not optimal for ArduinoJson.
+// See: https://arduinojson.org/v6/how-to/improve-speed/
+
 // See also
 // --------
 //

examples/JsonUdpBeacon/JsonUdpBeacon.ino

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 //
 // This example shows how to send a JSON document to a UDP socket.
@@ -32,7 +32,8 @@ EthernetUDP udp;
 void setup() {
   // Initialize serial port
   Serial.begin(9600);
-  while (!Serial) continue;
+  while (!Serial)
+    continue;
 
   // Initialize Ethernet libary
   if (!Ethernet.begin(mac)) {
@@ -46,8 +47,8 @@ void setup() {
 
 void loop() {
   // Allocate a temporary JsonDocument
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<500> doc;
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  JsonDocument doc(500);
 
   // Create the "analog" array
   JsonArray analogValues = doc.createNestedArray("analog");
@@ -86,6 +87,12 @@ void loop() {
   delay(10000);
 }
 
+// Performance issue?
+// ------------------
+//
+// EthernetUDP is an unbuffered stream, which is not optimal for ArduinoJson.
+// See: https://arduinojson.org/v6/how-to/improve-speed/
+
 // See also
 // --------
 //

examples/MsgPackParser/MsgPackParser.ino

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 //
 // This example shows how to deserialize a MessagePack document with
@@ -12,19 +12,15 @@
 void setup() {
   // Initialize serial port
   Serial.begin(9600);
-  while (!Serial) continue;
+  while (!Serial)
+    continue;
 
   // Allocate the JSON document
   //
-  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
+  // Inside the parentheses, 200 is the capacity of the memory pool in bytes.
   // Don't forget to change this value to match your JSON document.
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<200> doc;
-
-  // StaticJsonObject allocates memory on the stack, it can be
-  // replaced by DynamicJsonObject which allocates in the heap.
-  //
-  // DynamicJsonObject doc(200);
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  JsonDocument doc(200);
 
   // MessagePack input string.
   //
@@ -50,7 +46,7 @@ void setup() {
   // Test if parsing succeeded.
   if (error) {
     Serial.print("deserializeMsgPack() failed: ");
-    Serial.println(error.c_str());
+    Serial.println(error.f_str());
     return;
   }
 

examples/ProgmemExample/ProgmemExample.ino

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 //
 // This example shows the different ways you can use Flash strings with
@@ -14,44 +14,35 @@
 #include <ArduinoJson.h>
 
 void setup() {
-#ifdef PROGMEM  // <- check that Flash strings are supported
-
-  DynamicJsonDocument doc(1024);
+  JsonDocument doc(1024);
 
   // You can use a Flash String as your JSON input.
   // WARNING: the strings in the input will be duplicated in the JsonDocument.
   deserializeJson(doc, F("{\"sensor\":\"gps\",\"time\":1351824120,"
                          "\"data\":[48.756080,2.302038]}"));
-  JsonObject obj = doc.as<JsonObject>();
 
-  // You can use a Flash String to get an element of a JsonObject
+  // You can use a Flash String as a key to get a member from JsonDocument
   // No duplication is done.
-  long time = obj[F("time")];
+  long time = doc[F("time")];
 
-  // You can use a Flash String to set an element of a JsonObject
+  // You can use a Flash String as a key to set a member of a JsonDocument
   // WARNING: the content of the Flash String will be duplicated in the
   // JsonDocument.
-  obj[F("time")] = time;
+  doc[F("time")] = time;
 
-  // You can set a Flash String to a JsonObject or JsonArray:
+  // You can set a Flash String as the content of a JsonVariant
   // WARNING: the content of the Flash String will be duplicated in the
   // JsonDocument.
-  obj["sensor"] = F("gps");
+  doc["sensor"] = F("gps");
 
   // It works with serialized() too:
-  obj["sensor"] = serialized(F("\"gps\""));
-  obj["sensor"] = serialized(F("\xA3gps"), 3);
+  doc["sensor"] = serialized(F("\"gps\""));
+  doc["sensor"] = serialized(F("\xA3gps"), 3);
 
   // You can compare the content of a JsonVariant to a Flash String
-  if (obj["sensor"] == F("gps")) {
+  if (doc["sensor"] == F("gps")) {
     // ...
   }
-
-#else
-
-#warning PROGMEM is not supported on this platform
-
-#endif
 }
 
 void loop() {

examples/StringExample/StringExample.ino

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 //
 // This example shows the different ways you can use String with ArduinoJson.
@@ -13,49 +13,49 @@
 #include <ArduinoJson.h>
 
 void setup() {
-  DynamicJsonDocument doc(1024);
+  JsonDocument doc(1024);
 
   // You can use a String as your JSON input.
   // WARNING: the string in the input  will be duplicated in the JsonDocument.
   String input =
       "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
   deserializeJson(doc, input);
-  JsonObject obj = doc.as<JsonObject>();
 
-  // You can use a String to get an element of a JsonObject
+  // You can use a String as a key to get a member from JsonDocument
   // No duplication is done.
-  long time = obj[String("time")];
+  long time = doc[String("time")];
 
-  // You can use a String to set an element of a JsonObject
+  // You can use a String as a key to set a member of a JsonDocument
   // WARNING: the content of the String will be duplicated in the JsonDocument.
-  obj[String("time")] = time;
+  doc[String("time")] = time;
 
-  // You can get a String from a JsonObject or JsonArray:
+  // You can get the content of a JsonVariant as a String
   // No duplication is done, at least not in the JsonDocument.
-  String sensor = obj["sensor"];
+  String sensor = doc["sensor"];
 
   // Unfortunately, the following doesn't work (issue #118):
-  // sensor = obj["sensor"]; // <-  error "ambiguous overload for 'operator='"
+  // sensor = doc["sensor"]; // <-  error "ambiguous overload for 'operator='"
   // As a workaround, you need to replace by:
-  sensor = obj["sensor"].as<String>();
+  sensor = doc["sensor"].as<String>();
 
-  // You can set a String to a JsonObject or JsonArray:
+  // You can set a String as the content of a JsonVariant
   // WARNING: the content of the String will be duplicated in the JsonDocument.
-  obj["sensor"] = sensor;
+  doc["sensor"] = sensor;
 
   // It works with serialized() too:
-  obj["sensor"] = serialized(sensor);
+  doc["sensor"] = serialized(sensor);
 
   // You can also concatenate strings
   // WARNING: the content of the String will be duplicated in the JsonDocument.
-  obj[String("sen") + "sor"] = String("gp") + "s";
+  doc[String("sen") + "sor"] = String("gp") + "s";
 
   // You can compare the content of a JsonObject with a String
-  if (obj["sensor"] == sensor) {
+  if (doc["sensor"] == sensor) {
     // ...
   }
 
   // Lastly, you can print the resulting JSON to a String
+  // WARNING: it doesn't replace the content but appends to it
   String output;
   serializeJson(doc, output);
 }

extras/ArduinoJsonConfig.cmake.in

@@ -0,0 +1,4 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
+check_required_components("@PROJECT_NAME@")

extras/CompileOptions.cmake

@@ -0,0 +1,95 @@
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+	add_compile_options(
+		-pedantic
+		-Wall
+		-Wcast-align
+		-Wcast-qual
+		-Wconversion
+		-Wctor-dtor-privacy
+		-Wdisabled-optimization
+		-Werror
+		-Wextra
+		-Wformat=2
+		-Winit-self
+		-Wmissing-include-dirs
+		-Wnon-virtual-dtor
+		-Wold-style-cast
+		-Woverloaded-virtual
+		-Wparentheses
+		-Wredundant-decls
+		-Wshadow
+		-Wsign-conversion
+		-Wsign-promo
+		-Wstrict-aliasing
+		-Wundef
+	)
+
+	if(${COVERAGE})
+		set(CMAKE_CXX_FLAGS "-fprofile-arcs -ftest-coverage")
+	endif()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+	if((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.8) AND(NOT ${COVERAGE}))
+		add_compile_options(-g -Og)
+	else()
+		add_compile_options(-g -O0)
+	endif()
+
+	add_compile_options(
+		-Wstrict-null-sentinel
+		-Wno-vla # Allow VLA in tests
+	)
+	add_definitions(-DHAS_VARIABLE_LENGTH_ARRAY)
+
+	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.5)
+		add_compile_options(-Wlogical-op) # the flag exists in 4.4 but is buggy
+	endif()
+
+	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.6)
+		add_compile_options(-Wnoexcept)
+	endif()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+	add_compile_options(
+		-Wc++11-compat
+		-Wdeprecated-register
+		-Wno-vla-extension # Allow VLA in tests
+	)
+	add_definitions(
+		-DHAS_VARIABLE_LENGTH_ARRAY
+		-DSUBSCRIPT_CONFLICTS_WITH_BUILTIN_OPERATOR
+	)
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+	if((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.0) AND(NOT ${COVERAGE}))
+		add_compile_options(-g -Og)
+	else()
+		add_compile_options(-g -O0)
+	endif()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+	if((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 9.0) AND(NOT ${COVERAGE}))
+		add_compile_options(-g -Og)
+	else()
+		add_compile_options(-g -O0)
+	endif()
+endif()
+
+if(MSVC)
+	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+	add_compile_options(
+		/W4 # Set warning level
+		/WX # Treats all compiler warnings as errors.
+		/Zc:__cplusplus # Enable updated __cplusplus macro
+	)
+endif()
+
+if(MINGW)
+	# Static link on MinGW to avoid linking with the wrong DLLs when multiple
+	# versions are installed.
+	add_link_options(-static)
+endif()

extras/ci/arduino.sh

@@ -1,20 +0,0 @@
-#!/bin/bash -eux
-
-/sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_1.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :1 -ac -screen 0 1280x1024x16
-sleep 3
-export DISPLAY=:1.0
-
-mkdir -p /tmp/arduino
-curl -sS http://downloads.arduino.cc/arduino-$VERSION-linux64.tar.xz | tar xJ -C /tmp/arduino --strip 1 ||
-curl -sS http://downloads.arduino.cc/arduino-$VERSION-linux64.tgz | tar xz -C /tmp/arduino --strip 1
-export PATH=$PATH:/tmp/arduino/
-
-if [[ "$BOARD" =~ "arduino:samd:" ]]; then
-  arduino --install-boards arduino:samd
-fi
-
-ln -s $PWD /tmp/arduino/libraries/ArduinoJson
-
-for EXAMPLE in $PWD/examples/*/*.ino; do
-	arduino --verify --board $BOARD $EXAMPLE
-done

extras/ci/build.sh

@@ -1,14 +0,0 @@
-#!/bin/sh -ex
-
-export CC="$_CC"
-export CXX="$_CXX"
-
-if [ -n "$SANITIZE" ]; then
-	export CXXFLAGS="-fsanitize=$SANITIZE"
-	BUILD_TYPE="Debug"
-else
-	BUILD_TYPE="Release"
-fi
-
-cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE .
-cmake --build .

extras/ci/coverage.sh

@@ -1,9 +0,0 @@
-#!/bin/sh -eux
-
-cmake -DCOVERAGE=true .
-make 
-make test
-
-pip install --user cpp-coveralls 'requests[security]'
-pwd
-coveralls --include 'src' --gcov-options '\-lp'

extras/ci/espidf/CMakeLists.txt

@@ -0,0 +1,8 @@
+# ArduinoJson - https://arduinojson.org
+# Copyright © 2014-2023, Benoit BLANCHON
+# MIT License
+
+cmake_minimum_required(VERSION 3.5)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(example)

extras/ci/espidf/main/CMakeLists.txt

@@ -0,0 +1,8 @@
+# ArduinoJson - https://arduinojson.org
+# Copyright © 2014-2023, Benoit BLANCHON
+# MIT License
+
+idf_component_register(
+	SRCS "main.cpp"
+	INCLUDE_DIRS ""
+)

extras/ci/espidf/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

extras/ci/espidf/main/main.cpp

@@ -0,0 +1,16 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+
+extern "C" void app_main() {
+  char buffer[256];
+  JsonDocument doc(200);
+
+  doc["hello"] = "world";
+  serializeJson(doc, buffer);
+  deserializeJson(doc, buffer);
+  serializeMsgPack(doc, buffer);
+  deserializeMsgPack(doc, buffer);
+}

extras/ci/fuzz.sh

@@ -1,26 +0,0 @@
-#!/bin/bash -eux
-
-ROOT_DIR=$(dirname $0)/../../
-INCLUDE_DIR=${ROOT_DIR}/src/
-FUZZING_DIR=${ROOT_DIR}/extras/fuzzing/
-CXXFLAGS="-g -fprofile-instr-generate -fcoverage-mapping -fsanitize=address,undefined,fuzzer -fno-sanitize-recover=all"
-
-fuzz() {
-	NAME="$1"
-	FUZZER="${NAME}_fuzzer"
-	FUZZER_CPP="${FUZZING_DIR}/${NAME}_fuzzer.cpp"
-	CORPUS_DIR="${FUZZING_DIR}/${NAME}_corpus"
-	SEED_CORPUS_DIR="${FUZZING_DIR}/${NAME}_seed_corpus"
-
-	clang++-${CLANG} ${CXXFLAGS} -o ${FUZZER} -I$INCLUDE_DIR ${FUZZER_CPP}
-
-	export ASAN_OPTIONS="detect_leaks=0"
-	export LLVM_PROFILE_FILE="${FUZZER}.profraw"
-	./${FUZZER} "$CORPUS_DIR" "$SEED_CORPUS_DIR" -max_total_time=30 -timeout=1
-
-	llvm-profdata-${CLANG} merge -sparse ${LLVM_PROFILE_FILE} -o ${FUZZER}.profdata
-	llvm-cov-${CLANG} report ./${FUZZER} -instr-profile=${FUZZER}.profdata
-}
-
-fuzz json
-fuzz msgpack

extras/ci/particle.sh

@@ -0,0 +1,10 @@
+#!/bin/sh -ex
+
+BOARD=$1
+
+cd "$(dirname "$0")/../../"
+
+cp extras/particle/src/smocktest.ino src/
+cp extras/particle/project.properties ./
+
+particle compile "$BOARD"

extras/ci/platformio.sh

@@ -1,20 +0,0 @@
-#!/bin/sh -eux
-
-pip install --user platformio
-
-case $BOARD in
-uno)
-  platformio lib install 868 # SD library
-  platformio lib install 872 # Ethernet library
-  ;;
-esp01)
-  platformio lib uninstall 161 || true
-  platformio lib uninstall 868 || true
-  platformio lib uninstall 872 || true
-  ;;
-esac
-
-for EXAMPLE in $PWD/examples/*/*.ino; 
-do
-	platformio ci $EXAMPLE -l '.' -b $BOARD
-done

extras/ci/test.sh

@@ -1,4 +0,0 @@
-#!/bin/sh -ex
-
-"$(dirname "$0")/build.sh"
-ctest --output-on-failure .

extras/conf_test/avr.cpp

@@ -0,0 +1,18 @@
+#include <ArduinoJson.h>
+
+static_assert(ARDUINOJSON_ENABLE_PROGMEM == 1, "ARDUINOJSON_ENABLE_PROGMEM");
+
+static_assert(ARDUINOJSON_USE_LONG_LONG == 0, "ARDUINOJSON_USE_LONG_LONG");
+
+static_assert(ARDUINOJSON_SLOT_OFFSET_SIZE == 1,
+              "ARDUINOJSON_SLOT_OFFSET_SIZE");
+
+static_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, "ARDUINOJSON_LITTLE_ENDIAN");
+
+static_assert(ARDUINOJSON_USE_DOUBLE == 1, "ARDUINOJSON_USE_DOUBLE");
+
+static_assert(sizeof(ArduinoJson::detail::VariantSlot) == 8,
+              "sizeof(VariantSlot)");
+
+void setup() {}
+void loop() {}

extras/conf_test/esp8266.cpp

@@ -0,0 +1,16 @@
+#include <ArduinoJson.h>
+
+static_assert(ARDUINOJSON_USE_LONG_LONG == 1, "ARDUINOJSON_USE_LONG_LONG");
+
+static_assert(ARDUINOJSON_SLOT_OFFSET_SIZE == 2,
+              "ARDUINOJSON_SLOT_OFFSET_SIZE");
+
+static_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, "ARDUINOJSON_LITTLE_ENDIAN");
+
+static_assert(ARDUINOJSON_USE_DOUBLE == 1, "ARDUINOJSON_USE_DOUBLE");
+
+static_assert(sizeof(ArduinoJson::detail::VariantSlot) == 16,
+              "sizeof(VariantSlot)");
+
+void setup() {}
+void loop() {}

extras/conf_test/x64.cpp

@@ -0,0 +1,15 @@
+#include <ArduinoJson.h>
+
+static_assert(ARDUINOJSON_USE_LONG_LONG == 1, "ARDUINOJSON_USE_LONG_LONG");
+
+static_assert(ARDUINOJSON_SLOT_OFFSET_SIZE == 4,
+              "ARDUINOJSON_SLOT_OFFSET_SIZE");
+
+static_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, "ARDUINOJSON_LITTLE_ENDIAN");
+
+static_assert(ARDUINOJSON_USE_DOUBLE == 1, "ARDUINOJSON_USE_DOUBLE");
+
+static_assert(sizeof(ArduinoJson::detail::VariantSlot) == 32,
+              "sizeof(VariantSlot)");
+
+int main() {}

extras/conf_test/x86.cpp

@@ -0,0 +1,15 @@
+#include <ArduinoJson.h>
+
+static_assert(ARDUINOJSON_USE_LONG_LONG == 1, "ARDUINOJSON_USE_LONG_LONG");
+
+static_assert(ARDUINOJSON_SLOT_OFFSET_SIZE == 2,
+              "ARDUINOJSON_SLOT_OFFSET_SIZE");
+
+static_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, "ARDUINOJSON_LITTLE_ENDIAN");
+
+static_assert(ARDUINOJSON_USE_DOUBLE == 1, "ARDUINOJSON_USE_DOUBLE");
+
+static_assert(sizeof(ArduinoJson::detail::VariantSlot) == 16,
+              "sizeof(VariantSlot)");
+
+int main() {}

extras/fuzzing/CMakeLists.txt

@@ -1,17 +1,58 @@
-# ArduinoJson - arduinojson.org
-# Copyright Benoit Blanchon 2014-2020
+# ArduinoJson - https://arduinojson.org
+# Copyright © 2014-2023, Benoit BLANCHON
 # MIT License
 
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
 if(MSVC)
 	add_compile_options(-D_CRT_SECURE_NO_WARNINGS)
 endif()
 
-add_executable(msgpack_fuzzer
+add_executable(msgpack_reproducer
 	msgpack_fuzzer.cpp
-	fuzzer_main.cpp
+	reproducer.cpp
+)
+target_link_libraries(msgpack_reproducer
+	ArduinoJson
 )
 
-add_executable(json_fuzzer
+add_executable(json_reproducer
 	json_fuzzer.cpp
-	fuzzer_main.cpp
+	reproducer.cpp
 )
+target_link_libraries(json_reproducer
+	ArduinoJson
+)
+
+macro(add_fuzzer name)
+	set(FUZZER "${name}_fuzzer")
+	set(CORPUS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/${name}_corpus")
+	set(SEED_CORPUS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/${name}_seed_corpus")
+	add_executable("${FUZZER}"
+		"${name}_fuzzer.cpp"
+	)
+	target_link_libraries("${FUZZER}"
+		ArduinoJson
+	)
+	set_target_properties("${FUZZER}"
+		PROPERTIES
+			COMPILE_FLAGS "-fprofile-instr-generate -fcoverage-mapping -fsanitize=fuzzer -fno-sanitize-recover=all"
+			LINK_FLAGS "-fprofile-instr-generate -fcoverage-mapping -fsanitize=fuzzer -fno-sanitize-recover=all"
+	)
+
+	add_test(
+		NAME "${FUZZER}"
+		COMMAND "${FUZZER}" "${CORPUS_DIR}" "${SEED_CORPUS_DIR}" -max_total_time=5 -timeout=1
+	)
+
+	set_tests_properties("${FUZZER}"
+		PROPERTIES
+		LABELS "Fuzzing"
+	)
+endmacro()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 6)
+	add_fuzzer(json)
+	add_fuzzer(msgpack)
+endif()

extras/fuzzing/Makefile

@@ -1,6 +1,6 @@
 # CAUTION: this file is invoked by https://github.com/google/oss-fuzz
 
-CXXFLAGS += -I../../src -DARDUINOJSON_DEBUG
+CXXFLAGS += -I../../src -DARDUINOJSON_DEBUG=1 -std=c++11
 
 all: \
 	$(OUT)/json_fuzzer \

extras/fuzzing/json_fuzzer.cpp

@@ -1,7 +1,7 @@
 #include <ArduinoJson.h>
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  DynamicJsonDocument doc(4096);
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  JsonDocument doc(4096);
   DeserializationError error = deserializeJson(doc, data, size);
   if (!error) {
     std::string json;

extras/fuzzing/msgpack_fuzzer.cpp

@@ -1,7 +1,7 @@
 #include <ArduinoJson.h>
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  DynamicJsonDocument doc(4096);
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  JsonDocument doc(4096);
   DeserializationError error = deserializeMsgPack(doc, data, size);
   if (!error) {
     std::string json;

extras/fuzzing/reproducer.cpp

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 
 // This file is NOT use by Google's OSS fuzz
@@ -21,7 +21,7 @@ std::vector<uint8_t> read(const char* path) {
   }
 
   fseek(f, 0, SEEK_END);
-  size_t size = ftell(f);
+  size_t size = static_cast<size_t>(ftell(f));
   fseek(f, 0, SEEK_SET);
 
   std::vector<uint8_t> buffer(size);

extras/particle/project.properties

@@ -0,0 +1 @@
+name=ArduinoJsonCI

extras/particle/src/smocktest.ino

@@ -0,0 +1,5 @@
+#include "ArduinoJson.h"
+
+void setup() {}
+
+void loop() {}

extras/scripts/build-arduino-package.sh

@@ -1,20 +1,23 @@
 #!/bin/bash
 
-TAG=$(git describe)
-OUTPUT="ArduinoJson-$TAG.zip"
+set -eu
 
-cd $(dirname $0)/../../..
+INPUT=$1
+OUTPUT=$2
+
+cd "$INPUT"
 
 # remove existing file
-rm -f $OUTPUT
+rm -f "$OUTPUT"
 
 # create zip
-7z a $OUTPUT \
-	ArduinoJson/CHANGELOG.md \
-	ArduinoJson/examples \
-	ArduinoJson/src \
-	ArduinoJson/keywords.txt \
-	ArduinoJson/library.properties \
-	ArduinoJson/LICENSE.md \
-	ArduinoJson/README.md \
-	ArduinoJson/ArduinoJson.h
+7z a "$OUTPUT" \
+	-xr!.vs \
+	CHANGELOG.md \
+	examples \
+	src \
+	keywords.txt \
+	library.properties \
+	LICENSE.txt \
+	README.md \
+	ArduinoJson.h

extras/scripts/build-single-header.sh

@@ -2,11 +2,10 @@
 
 set -e
 
-TAG=$(git describe)
-RE_RELATIVE_INCLUDE='^#include[[:space:]]*"(.*)"'
-RE_ABSOLUTE_INCLUDE='^#include[[:space:]]*<(ArduinoJson/.*)>'
-RE_SYSTEM_INCLUDE='^#include[[:space:]]*<(.*)>'
-RE_EMPTY='^(#pragma[[:space:]]+once)?[[:space:]]*(//.*)?$'
+RE_RELATIVE_INCLUDE='^#[[:space:]]*include[[:space:]]*"(.*)"'
+RE_ABSOLUTE_INCLUDE='^#[[:space:]]*include[[:space:]]*<(ArduinoJson/.*)>'
+RE_SYSTEM_INCLUDE='^#[[:space:]]*include[[:space:]]*<(.*)>'
+RE_EMPTY='^(#[[:space:]]*pragma[[:space:]]+once)?[[:space:]]*(//.*)?$'
 SRC_DIRECTORY="$(realpath "$(dirname $0)/../../src")"
 
 
@@ -54,29 +53,13 @@ process()
 }
 
 simplify_namespaces() {
-	perl -p0i -e 's|\}  // namespace ARDUINOJSON_NAMESPACE\r?\nnamespace ARDUINOJSON_NAMESPACE \{\r?\n||igs' "$1"
+	perl -p0i -e 's|ARDUINOJSON_END_PUBLIC_NAMESPACE\r?\nARDUINOJSON_BEGIN_PUBLIC_NAMESPACE\r?\n||igs' "$1"
+	perl -p0i -e 's|ARDUINOJSON_END_PRIVATE_NAMESPACE\r?\nARDUINOJSON_BEGIN_PRIVATE_NAMESPACE\r?\n||igs' "$1"
 	rm -f "$1.bak"
 }
 
-cd $(dirname $0)/../..
 INCLUDED=()
-process src/ArduinoJson.h true > ../ArduinoJson-$TAG.h
-simplify_namespaces ../ArduinoJson-$TAG.h
-g++ -x c++ -c -o ../smoketest.o - <<END
-#include "../ArduinoJson-$TAG.h"
-int main() {
-	StaticJsonDocument<300> doc;
-	deserializeJson(doc, "{}");
-}
-END
-
-INCLUDED=()
-process src/ArduinoJson.hpp true > ../ArduinoJson-$TAG.hpp
-simplify_namespaces ../ArduinoJson-$TAG.hpp
-g++ -x c++ -c -o ../smoketest.o - <<END
-#include "../ArduinoJson-$TAG.hpp"
-int main() {
-	ArduinoJson::StaticJsonDocument<300> doc;
-	ArduinoJson::deserializeJson(doc, "{}");
-}
-END
+INPUT=$1
+OUTPUT=$2
+process "$INPUT" true > "$OUTPUT"
+simplify_namespaces "$OUTPUT"

extras/scripts/create-build-envs.sh

@@ -1,29 +0,0 @@
-#!/bin/bash
-
-export PATH="$PATH:/Applications/CMake.app/Contents/bin/"
-
-cd $(dirname $0)/../..
-ROOT=$(pwd)
-
-mkdir "build"
-cd build
-BUILD=$(pwd)
-
-build-env()
-{
-	cd $BUILD
-	mkdir "$1"
-	cd "$1"
-	cmake "$ROOT" -G "$2"
-}
-
-if [[ $(uname) == MINGW* ]]
-then
-	build-env "Make" "MinGW Makefiles"
-	build-env "SublimeText" "Sublime Text 2 - Ninja"
-	build-env "VisualStudio" "Visual Studio 14 2015"
-else
-	build-env "SublimeText" "Sublime Text 2 - Ninja"
-	build-env "Make" "Unix Makefiles"
-	build-env "Xcode" "Xcode"
-fi

extras/scripts/get-release-body.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+set -eu
+
+TAG="$1"
+CHANGELOG="$2"
+
+cat << END
+## Changes
+
+$(awk '/\* /{ FOUND=1 } /^[[:space:]]*$/ { if(FOUND) exit } { if(FOUND) print }' "$CHANGELOG")
+
+[View version history](https://github.com/bblanchon/ArduinoJson/blob/$TAG/CHANGELOG.md)
+END

extras/scripts/get-release-page.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -eu
+
+VERSION="$1"
+CHANGELOG="$2"
+FRONTMATTER="$3"
+
+cat << END
+---
+branch: v6
+version: $VERSION
+date: '$(date +'%Y-%m-%d')'
+$(cat "$FRONTMATTER")
+---
+
+$(awk '/\* /{ FOUND=1; print; next } { if (FOUND) exit}' "$CHANGELOG")
+END

extras/scripts/publish-particle-library.sh

@@ -9,7 +9,7 @@ trap 'rm -rf "$WORK_DIR"' EXIT
 cp "$SOURCE_DIR/README.md" "$WORK_DIR/README.md"
 cp "$SOURCE_DIR/CHANGELOG.md" "$WORK_DIR/CHANGELOG.md"
 cp "$SOURCE_DIR/library.properties" "$WORK_DIR/library.properties"
-cp "$SOURCE_DIR/LICENSE.md" "$WORK_DIR/LICENSE.txt"
+cp "$SOURCE_DIR/LICENSE.txt" "$WORK_DIR/LICENSE.txt"
 cp -r "$SOURCE_DIR/src" "$WORK_DIR/"
 cp -r "$SOURCE_DIR/examples" "$WORK_DIR/"
 

extras/scripts/publish.sh

@@ -2,43 +2,57 @@
 
 set -eu
 
+which awk sed jq 7z curl perl >/dev/null
+
 cd "$(dirname "$0")/../.."
 
+if ! git diff --quiet --exit-code; then
+	echo "Repository contains uncommitted changes"
+	exit
+fi
+
 VERSION="$1"
 DATE=$(date +%F)
 TAG="v$VERSION"
-VERSION_REGEX="[0-9a-z\\.\\-]+"
+VERSION_REGEX='[0-9]+\.[0-9]+\.[0-9]+(-[a-z0-9]+)?'
 
 update_version_in_source () {
 	IFS=".-" read MAJOR MINOR REVISION EXTRA < <(echo "$VERSION")
 	UNDERLINE=$(printf -- '-%.0s' $(seq 1 ${#TAG}))
 
-	sed -i~ -bE "s/version=$VERSION_REGEX/version=$VERSION/; s|ardu-badge.com/ArduinoJson/$VERSION_REGEX|ardu-badge.com/ArduinoJson/$VERSION|; " README.md
-	rm README.md*~
+	sed -i~ -bE "1,20{s/$VERSION_REGEX/$VERSION/g}" README.md
+	rm README.md~
 
 	sed -i~ -bE "4s/HEAD/$TAG ($DATE)/; 5s/-+/$UNDERLINE/" CHANGELOG.md
-	rm CHANGELOG.md*~
+	rm CHANGELOG.md~
+
+	sed -i~ -bE "s/(project\\s*\\(ArduinoJson\\s+VERSION\\s+).*?\\)/\\1$MAJOR.$MINOR.$REVISION)/" CMakeLists.txt
+	rm CMakeLists.txt~
 
 	sed -i~ -bE "s/\"version\":.*$/\"version\": \"$VERSION\",/" library.json
-	rm library.json*~
+	rm library.json~
 
 	sed -i~ -bE "s/version=.*$/version=$VERSION/" library.properties
-	rm library.properties*~
+	rm library.properties~
 
 	sed -i~ -bE "s/version: .*$/version: $VERSION.{build}/" appveyor.yml
-	rm appveyor.yml*~
+	rm appveyor.yml~
+
+	sed -i~ -bE "s/^version: .*$/version: \"$VERSION\"/" idf_component.yml
+	rm idf_component.yml~
 
 	sed -i~ -bE \
 		-e "s/ARDUINOJSON_VERSION .*$/ARDUINOJSON_VERSION \"$VERSION\"/" \
 		-e "s/ARDUINOJSON_VERSION_MAJOR .*$/ARDUINOJSON_VERSION_MAJOR $MAJOR/" \
 		-e "s/ARDUINOJSON_VERSION_MINOR .*$/ARDUINOJSON_VERSION_MINOR $MINOR/" \
 		-e "s/ARDUINOJSON_VERSION_REVISION .*$/ARDUINOJSON_VERSION_REVISION $REVISION/" \
+		-e "s/ARDUINOJSON_VERSION_MACRO .*$/ARDUINOJSON_VERSION_MACRO V$MAJOR$MINOR$REVISION/" \
 		src/ArduinoJson/version.hpp
 	rm src/ArduinoJson/version.hpp*~
 }
 
 commit_new_version () {
-	git add src/ArduinoJson/version.hpp README.md CHANGELOG.md library.json library.properties appveyor.yml
+	git add src/ArduinoJson/version.hpp README.md CHANGELOG.md library.json library.properties appveyor.yml CMakeLists.txt idf_component.yml
 	git commit -m "Set version to $VERSION"
 }
 
@@ -56,6 +70,10 @@ commit_new_version
 add_tag
 push
 
-extras/scripts/build-arduino-package.sh
-extras/scripts/build-single-header.sh
-extras/scripts/wandbox/publish.sh "../ArduinoJson-$TAG.h"
+extras/scripts/build-arduino-package.sh . "../ArduinoJson-$TAG.zip"
+extras/scripts/build-single-header.sh "src/ArduinoJson.h" "../ArduinoJson-$TAG.h"
+extras/scripts/build-single-header.sh "src/ArduinoJson.hpp" "../ArduinoJson-$TAG.hpp"
+extras/scripts/wandbox/publish.sh "../ArduinoJson-$TAG.h" > "../ArduinoJson-$TAG-wandbox.txt" || echo "Wandbox failed!"
+extras/scripts/get-release-page.sh "$VERSION" "CHANGELOG.md" "../ArduinoJson-$TAG-wandbox.txt" > "../ArduinoJson-$TAG.md"
+
+echo "You can now copy ../ArduinoJson-$TAG.md into arduinojson.org/collections/_versions/$VERSION.md"

extras/scripts/wandbox/JsonGeneratorExample.cpp

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 //
 // This example shows how to generate a JSON document with ArduinoJson.
@@ -10,20 +10,10 @@
 int main() {
   // Allocate the JSON document
   //
-  // Inside the brackets, 200 is the RAM allocated to this document.
+  // Inside the parentheses, 200 is the RAM allocated to this document.
   // Don't forget to change this value to match your requirement.
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<200> doc;
-
-  // StaticJsonObject allocates memory on the stack, it can be
-  // replaced by DynamicJsonDocument which allocates in the heap.
-  //
-  // DynamicJsonDocument  doc(200);
-
-  // StaticJsonObject allocates memory on the stack, it can be
-  // replaced by DynamicJsonDocument which allocates in the heap.
-  //
-  // DynamicJsonDocument  doc(200);
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  JsonDocument doc(200);
 
   // Add values in the document
   //

extras/scripts/wandbox/JsonParserExample.cpp

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 //
 // This example shows how to deserialize a JSON document with ArduinoJson.
@@ -10,15 +10,10 @@
 int main() {
   // Allocate the JSON document
   //
-  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
+  // Inside the parentheses, 200 is the capacity of the memory pool in bytes.
   // Don't forget to change this value to match your JSON document.
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<300> doc;
-
-  // StaticJsonDocument<N> allocates memory on the stack, it can be
-  // replaced by DynamicJsonDocument which allocates in the heap.
-  //
-  // DynamicJsonDocument doc(200);
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  JsonDocument doc(300);
 
   // JSON input string.
   //

extras/scripts/wandbox/MsgPackParserExample.cpp

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 //
 // This example shows how to generate a JSON document with ArduinoJson.
@@ -10,15 +10,10 @@
 int main() {
   // Allocate the JSON document
   //
-  // Inside the brackets, 300 is the size of the memory pool in bytes.
+  // Inside the parentheses, 300 is the size of the memory pool in bytes.
   // Don't forget to change this value to match your JSON document.
-  // Use arduinojson.org/assistant to compute the capacity.
-  StaticJsonDocument<300> doc;
-
-  // StaticJsonObject allocates memory on the stack, it can be
-  // replaced by DynamicJsonObject which allocates in the heap.
-  //
-  // DynamicJsonObject doc(200);
+  // Use https://arduinojson.org/assistant to compute the capacity.
+  JsonDocument doc(300);
 
   // MessagePack input string.
   //

extras/scripts/wandbox/publish.sh

@@ -14,14 +14,14 @@ compile() {
 {
   "code":$(read_string "$FILE_PATH"),
   "codes": [{"file":"ArduinoJson.h","code":$(read_string "$ARDUINOJSON_H")}],
-  "options": "warning",
-  "compiler": "gcc-4.9.3",
+  "options": "warning,c++11",
+  "compiler": "gcc-5.5.0",
   "save": true
 }
 END
 	URL=$(curl -sS -H "Content-type: application/json" -d @parameters.json  https://wandbox.org/api/compile.json | jq --raw-output .url)
 	rm parameters.json
-	echo "  $1: $URL"
+	[ -n "$URL" ] && echo "$1: $URL"
 }
 
 compile "JsonGeneratorExample"

extras/tests/.clang-tidy

@@ -0,0 +1 @@
+Checks:              '-clang-analyzer-security.insecureAPI.*'

extras/tests/CMakeLists.txt

@@ -1,79 +1,18 @@
-# ArduinoJson - arduinojson.org
-# Copyright Benoit Blanchon 2014-2020
+# ArduinoJson - https://arduinojson.org
+# Copyright © 2014-2023, Benoit BLANCHON
 # MIT License
 
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
 add_subdirectory(catch)
 
-if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
-	add_compile_options(
-		-pedantic
-		-Wall
-		-Wcast-align
-		-Wcast-qual
-		-Wconversion
-		-Wctor-dtor-privacy
-		-Wdisabled-optimization
-		-Werror
-		-Wextra
-		-Wformat=2
-		-Winit-self
-		-Wmissing-include-dirs
-		-Wnon-virtual-dtor
-		-Wold-style-cast
-		-Woverloaded-virtual
-		-Wparentheses
-		-Wredundant-decls
-		-Wshadow
-		-Wsign-promo
-		-Wstrict-aliasing
-		-Wundef
-	)
-
-	if(NOT MINGW)
-		add_compile_options(
-			-std=c++98
-		)
-	endif()
-endif()
-
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-	add_compile_options(
-		-Wstrict-null-sentinel
-		-Wno-vla # Allow VLA in tests
-	)
-	add_definitions(-DHAS_VARIABLE_LENGTH_ARRAY)
-
-	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.5)
-		add_compile_options(-Wlogical-op) # the flag exists in 4.4 but is buggy
-	endif()
-
-	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.6)
-		add_compile_options(-Wnoexcept)
-	endif()
-endif()
-
-if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-	add_compile_options(
-		-Wc++11-compat
-		-Wdeprecated-register
-		-Wno-vla-extension # Allow VLA in tests
-	)
-	add_definitions(
-		-DHAS_VARIABLE_LENGTH_ARRAY
-		-DSUBSCRIPT_CONFLICTS_WITH_BUILTIN_OPERATOR
-	)
-endif()
-
-if(MSVC)
-	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-	add_compile_options(
-		/W4 # Set warning level
-		/WX # Treats all compiler warnings as errors.
-	)
-endif()
+link_libraries(ArduinoJson catch)
 
 include_directories(Helpers)
-add_subdirectory(ElementProxy)
+add_subdirectory(Cpp17)
+add_subdirectory(Cpp20)
+add_subdirectory(FailingBuilds)
 add_subdirectory(IntegrationTests)
 add_subdirectory(JsonArray)
 add_subdirectory(JsonDeserializer)
@@ -81,8 +20,7 @@ add_subdirectory(JsonDocument)
 add_subdirectory(JsonObject)
 add_subdirectory(JsonSerializer)
 add_subdirectory(JsonVariant)
-add_subdirectory(MemberProxy)
-add_subdirectory(MemoryPool)
+add_subdirectory(ResourceManager)
 add_subdirectory(Misc)
 add_subdirectory(MixedConfiguration)
 add_subdirectory(MsgPackDeserializer)

extras/tests/Cpp17/CMakeLists.txt

@@ -0,0 +1,29 @@
+# ArduinoJson - https://arduinojson.org
+# Copyright © 2014-2023, Benoit BLANCHON
+# MIT License
+
+if(MSVC_VERSION LESS 1910)
+	return()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5)
+	return()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7)
+	return()
+endif()
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_executable(Cpp17Tests
+	string_view.cpp
+)
+
+add_test(Cpp17 Cpp17Tests)
+
+set_tests_properties(Cpp17
+	PROPERTIES
+		LABELS "Catch"
+)

extras/tests/Cpp17/string_view.cpp

@@ -0,0 +1,105 @@
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#include <string_view>
+
+#if !ARDUINOJSON_ENABLE_STRING_VIEW
+#  error ARDUINOJSON_ENABLE_STRING_VIEW must be set to 1
+#endif
+
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofString;
+
+TEST_CASE("string_view") {
+  JsonDocument doc(256);
+  JsonVariant variant = doc.to<JsonVariant>();
+
+  SECTION("deserializeJson()") {
+    auto err = deserializeJson(doc, std::string_view("123", 2));
+    REQUIRE(err == DeserializationError::Ok);
+    REQUIRE(doc.as<int>() == 12);
+  }
+
+  SECTION("JsonDocument::set()") {
+    doc.set(std::string_view("123", 2));
+    REQUIRE(doc.as<std::string>() == "12");
+  }
+
+  SECTION("JsonDocument::operator[]() const") {
+    doc["ab"] = "Yes";
+    doc["abc"] = "No";
+    REQUIRE(doc[std::string_view("abc", 2)] == "Yes");
+  }
+
+  SECTION("JsonDocument::operator[]()") {
+    doc[std::string_view("abc", 2)] = "Yes";
+    REQUIRE(doc["ab"] == "Yes");
+  }
+
+  SECTION("JsonVariant::operator==()") {
+    variant.set("A");
+    REQUIRE(variant == std::string_view("AX", 1));
+    REQUIRE_FALSE(variant == std::string_view("BX", 1));
+  }
+
+  SECTION("JsonVariant::operator>()") {
+    variant.set("B");
+    REQUIRE(variant > std::string_view("AX", 1));
+    REQUIRE_FALSE(variant > std::string_view("CX", 1));
+  }
+
+  SECTION("JsonVariant::operator<()") {
+    variant.set("B");
+    REQUIRE(variant < std::string_view("CX", 1));
+    REQUIRE_FALSE(variant < std::string_view("AX", 1));
+  }
+
+  SECTION("String deduplication") {
+    doc.add(std::string_view("example one", 7));
+    REQUIRE(doc.memoryUsage() == sizeofArray(1) + sizeofString(7));
+
+    doc.add(std::string_view("example two", 7));
+    REQUIRE(doc.memoryUsage() == sizeofArray(2) + sizeofString(7));
+
+    doc.add(std::string_view("example\0tree", 12));
+    REQUIRE(doc.memoryUsage() ==
+            sizeofArray(3) + sizeofString(7) + sizeofString(12));
+
+    doc.add(std::string_view("example\0tree and a half", 12));
+    REQUIRE(doc.memoryUsage() ==
+            sizeofArray(4) + sizeofString(7) + sizeofString(12));
+  }
+
+  SECTION("as<std::string_view>()") {
+    doc["s"] = "Hello World";
+    doc["i"] = 42;
+    REQUIRE(doc["s"].as<std::string_view>() == std::string_view("Hello World"));
+    REQUIRE(doc["i"].as<std::string_view>() == std::string_view());
+  }
+
+  SECTION("is<std::string_view>()") {
+    doc["s"] = "Hello World";
+    doc["i"] = 42;
+    REQUIRE(doc["s"].is<std::string_view>() == true);
+    REQUIRE(doc["i"].is<std::string_view>() == false);
+  }
+
+  SECTION("String containing NUL") {
+    doc.set(std::string("hello\0world", 11));
+    REQUIRE(doc.as<std::string_view>().size() == 11);
+    REQUIRE(doc.as<std::string_view>() == std::string_view("hello\0world", 11));
+  }
+}
+
+using ArduinoJson::detail::adaptString;
+
+TEST_CASE("StringViewAdapter") {
+  std::string_view str("bravoXXX", 5);
+  auto adapter = adaptString(str);
+
+  CHECK(stringCompare(adapter, adaptString("alpha", 5)) > 0);
+  CHECK(stringCompare(adapter, adaptString("bravo", 5)) == 0);
+  CHECK(stringCompare(adapter, adaptString("charlie", 7)) < 0);
+
+  CHECK(adapter.size() == 5);
+}

extras/tests/Cpp20/CMakeLists.txt

@@ -0,0 +1,29 @@
+# ArduinoJson - https://arduinojson.org
+# Copyright © 2014-2023, Benoit BLANCHON
+# MIT License
+
+if(MSVC_VERSION LESS 1910)
+	return()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10)
+	return()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10)
+	return()
+endif()
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_executable(Cpp20Tests
+	smoke_test.cpp
+)
+
+add_test(Cpp20 Cpp20Tests)
+
+set_tests_properties(Cpp20
+	PROPERTIES
+		LABELS "Catch"
+)

extras/tests/Cpp20/smoke_test.cpp

@@ -0,0 +1,15 @@
+#include <ArduinoJson.h>
+
+#include <catch.hpp>
+#include <string>
+
+TEST_CASE("C++20 smoke test") {
+  JsonDocument doc(128);
+
+  deserializeJson(doc, "{\"hello\":\"world\"}");
+  REQUIRE(doc["hello"] == "world");
+
+  std::string json;
+  serializeJson(doc, json);
+  REQUIRE(json == "{\"hello\":\"world\"}");
+}

extras/tests/ElementProxy/CMakeLists.txt

@@ -1,15 +0,0 @@
-# ArduinoJson - arduinojson.org
-# Copyright Benoit Blanchon 2014-2020
-# MIT License
-
-add_executable(ElementProxyTests
-	add.cpp
-	clear.cpp
-	compare.cpp
-	remove.cpp
-	set.cpp
-	size.cpp
-)
-
-target_link_libraries(ElementProxyTests catch)
-add_test(ElementProxy ElementProxyTests)

extras/tests/ElementProxy/add.cpp

@@ -1,26 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("ElementProxy::add()") {
-  DynamicJsonDocument doc(4096);
-  doc.addElement();
-  ElementProxy<JsonDocument&> ep = doc[0];
-
-  SECTION("add(int)") {
-    ep.add(42);
-
-    REQUIRE(doc.as<std::string>() == "[[42]]");
-  }
-
-  SECTION("add(const char*)") {
-    ep.add("world");
-
-    REQUIRE(doc.as<std::string>() == "[[\"world\"]]");
-  }
-}

extras/tests/ElementProxy/clear.cpp

@@ -1,28 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("ElementProxy::clear()") {
-  DynamicJsonDocument doc(4096);
-  doc.addElement();
-  ElementProxy<JsonDocument&> ep = doc[0];
-
-  SECTION("size goes back to zero") {
-    ep.add(42);
-    ep.clear();
-
-    REQUIRE(ep.size() == 0);
-  }
-
-  SECTION("isNull() return true") {
-    ep.add("hello");
-    ep.clear();
-
-    REQUIRE(ep.isNull() == true);
-  }
-}

extras/tests/ElementProxy/compare.cpp

@@ -1,28 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("ElementProxy::operator==()") {
-  DynamicJsonDocument doc(4096);
-
-  SECTION("same value") {
-    doc.add(1);
-    doc.add(1);
-
-    REQUIRE(doc[0] == doc[1]);
-    REQUIRE_FALSE(doc[0] != doc[1]);
-  }
-
-  SECTION("different values") {
-    doc.add(1);
-    doc.add(2);
-
-    REQUIRE_FALSE(doc[0] == doc[1]);
-    REQUIRE(doc[0] != doc[1]);
-  }
-}

extras/tests/ElementProxy/remove.cpp

@@ -1,56 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("ElementProxy::remove()") {
-  DynamicJsonDocument doc(4096);
-  doc.addElement();
-  ElementProxy<JsonDocument&> ep = doc[0];
-
-  SECTION("remove(int)") {
-    ep.add(1);
-    ep.add(2);
-    ep.add(3);
-
-    ep.remove(1);
-
-    REQUIRE(ep.as<std::string>() == "[1,3]");
-  }
-
-  SECTION("remove(const char *)") {
-    ep["a"] = 1;
-    ep["b"] = 2;
-
-    ep.remove("a");
-
-    REQUIRE(ep.as<std::string>() == "{\"b\":2}");
-  }
-
-  SECTION("remove(std::string)") {
-    ep["a"] = 1;
-    ep["b"] = 2;
-
-    ep.remove(std::string("b"));
-
-    REQUIRE(ep.as<std::string>() == "{\"a\":1}");
-  }
-
-#ifdef HAS_VARIABLE_LENGTH_ARRAY
-  SECTION("remove(vla)") {
-    ep["a"] = 1;
-    ep["b"] = 2;
-
-    int i = 4;
-    char vla[i];
-    strcpy(vla, "b");
-    ep.remove(vla);
-
-    REQUIRE(ep.as<std::string>() == "{\"a\":1}");
-  }
-#endif
-}

extras/tests/ElementProxy/set.cpp

@@ -1,26 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("ElementProxy::set()") {
-  DynamicJsonDocument doc(4096);
-  doc.addElement();
-  ElementProxy<JsonDocument&> ep = doc[0];
-
-  SECTION("set(int)") {
-    ep.set(42);
-
-    REQUIRE(doc.as<std::string>() == "[42]");
-  }
-
-  SECTION("set(const char*)") {
-    ep.set("world");
-
-    REQUIRE(doc.as<std::string>() == "[\"world\"]");
-  }
-}

extras/tests/ElementProxy/size.cpp

@@ -1,30 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("ElementProxy::size()") {
-  DynamicJsonDocument doc(4096);
-  doc.addElement();
-  ElementProxy<JsonDocument&> ep = doc[0];
-
-  SECTION("returns 0") {
-    REQUIRE(ep.size() == 0);
-  }
-
-  SECTION("as an array, returns 2") {
-    ep.add(1);
-    ep.add(2);
-    REQUIRE(ep.size() == 2);
-  }
-
-  SECTION("as an object, returns 2") {
-    ep["a"] = 1;
-    ep["b"] = 2;
-    REQUIRE(ep.size() == 2);
-  }
-}

extras/tests/FailingBuilds/CMakeLists.txt

@@ -0,0 +1,36 @@
+# ArduinoJson - https://arduinojson.org
+# Copyright © 2014-2023, Benoit BLANCHON
+# MIT License
+
+macro(build_should_fail target)
+	set_target_properties(${target}
+		PROPERTIES
+			EXCLUDE_FROM_ALL TRUE
+			EXCLUDE_FROM_DEFAULT_BUILD TRUE
+	)
+	add_test(
+		NAME ${target}
+			COMMAND ${CMAKE_COMMAND} --build . --target ${target} --config $<CONFIGURATION>
+			WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+	)
+	set_tests_properties(${target}
+		PROPERTIES
+			WILL_FAIL TRUE
+			LABELS "WillFail;Catch"
+	)
+endmacro()
+
+add_executable(Issue978 Issue978.cpp)
+build_should_fail(Issue978)
+
+add_executable(read_long_long read_long_long.cpp)
+build_should_fail(read_long_long)
+
+add_executable(write_long_long write_long_long.cpp)
+build_should_fail(write_long_long)
+
+add_executable(variant_as_char variant_as_char.cpp)
+build_should_fail(variant_as_char)
+
+add_executable(assign_char assign_char.cpp)
+build_should_fail(assign_char)

extras/tests/FailingBuilds/Issue978.cpp

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
@@ -8,6 +8,6 @@ struct Stream {};
 
 int main() {
   Stream* stream = 0;
-  DynamicJsonDocument doc(1024);
+  JsonDocument doc(1024);
   deserializeJson(doc, stream);
 }

extras/tests/FailingBuilds/assign_char.cpp

@@ -0,0 +1,12 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+
+// See issue #1498
+
+int main() {
+  JsonDocument doc(1024);
+  doc["dummy"] = 'A';
+}

extras/tests/FailingBuilds/read_long_long.cpp

@@ -0,0 +1,16 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#define ARDUINOJSON_USE_LONG_LONG 0
+#include <ArduinoJson.h>
+
+#if defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ >= 8
+#  error This test requires sizeof(long) < 8
+#endif
+
+ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(long long)
+int main() {
+  JsonDocument doc(1024);
+  doc["dummy"].as<long long>();
+}

extras/tests/FailingBuilds/variant_as_char.cpp

@@ -0,0 +1,12 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+
+// See issue #1498
+
+int main() {
+  JsonDocument doc(1024);
+  doc["dummy"].as<char>();
+}

extras/tests/FailingBuilds/write_long_long.cpp

@@ -0,0 +1,15 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#define ARDUINOJSON_USE_LONG_LONG 0
+#include <ArduinoJson.h>
+
+#if defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ >= 8
+#  error This test requires sizeof(long) < 8
+#endif
+
+int main() {
+  JsonDocument doc(1024);
+  doc["dummy"] = static_cast<long long>(42);
+}

extras/tests/Helpers/Allocators.hpp

@@ -0,0 +1,219 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/Allocator.hpp>
+
+#include <sstream>
+
+struct FailingAllocator : ArduinoJson::Allocator {
+  static FailingAllocator* instance() {
+    static FailingAllocator allocator;
+    return &allocator;
+  }
+
+ private:
+  FailingAllocator() = default;
+  ~FailingAllocator() = default;
+
+  void* allocate(size_t) override {
+    return nullptr;
+  }
+
+  void deallocate(void*) override {}
+
+  void* reallocate(void*, size_t) override {
+    return nullptr;
+  }
+};
+
+class AllocatorLog {
+ public:
+  static std::string Allocate(size_t s) {
+    char buffer[32];
+    sprintf(buffer, "allocate(%zu)", s);
+    return buffer;
+  }
+
+  static std::string AllocateFail(size_t s) {
+    char buffer[32];
+    sprintf(buffer, "allocate(%zu) -> nullptr", s);
+    return buffer;
+  }
+
+  static std::string Reallocate(size_t s1, size_t s2) {
+    char buffer[32];
+    sprintf(buffer, "reallocate(%zu, %zu)", s1, s2);
+    return buffer;
+  };
+
+  static std::string ReallocateFail(size_t s1, size_t s2) {
+    char buffer[32];
+    sprintf(buffer, "reallocate(%zu, %zu) -> nullptr", s1, s2);
+    return buffer;
+  };
+
+  static std::string Deallocate(size_t s) {
+    char buffer[32];
+    sprintf(buffer, "deallocate(%zu)", s);
+    return buffer;
+  };
+
+  AllocatorLog& operator<<(const std::string& s) {
+    log_ << s << "\n";
+    return *this;
+  }
+
+  std::string str() const {
+    auto s = log_.str();
+    if (s.empty())
+      return "(empty)";
+    s.pop_back();  // remove the trailing '\n'
+    return s;
+  }
+
+  bool operator==(const AllocatorLog& other) const {
+    return str() == other.str();
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, const AllocatorLog& log) {
+    os << log.str();
+    return os;
+  }
+
+ private:
+  std::ostringstream log_;
+};
+
+class SpyingAllocator : public ArduinoJson::Allocator {
+ public:
+  SpyingAllocator(
+      Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())
+      : upstream_(upstream) {}
+  virtual ~SpyingAllocator() {}
+
+  void* allocate(size_t n) override {
+    auto block = reinterpret_cast<AllocatedBlock*>(
+        upstream_->allocate(sizeof(AllocatedBlock) + n - 1));
+    if (block) {
+      log_ << AllocatorLog::Allocate(n);
+      block->size = n;
+      return block->payload;
+    } else {
+      log_ << AllocatorLog::AllocateFail(n);
+      return nullptr;
+    }
+  }
+
+  void deallocate(void* p) override {
+    auto block = AllocatedBlock::fromPayload(p);
+    log_ << AllocatorLog::Deallocate(block->size);
+    upstream_->deallocate(block);
+  }
+
+  void* reallocate(void* p, size_t n) override {
+    auto block = AllocatedBlock::fromPayload(p);
+    auto oldSize = block->size;
+    block = reinterpret_cast<AllocatedBlock*>(
+        upstream_->reallocate(block, sizeof(AllocatedBlock) + n - 1));
+    if (block) {
+      log_ << AllocatorLog::Reallocate(oldSize, n);
+      ARDUINOJSON_ASSERT(block->size == oldSize);
+      block->size = n;
+      return block->payload;
+    } else {
+      log_ << AllocatorLog::ReallocateFail(oldSize, n);
+      return nullptr;
+    }
+  }
+
+  void clearLog() {
+    log_ = AllocatorLog();
+  }
+
+  const AllocatorLog& log() const {
+    return log_;
+  }
+
+ private:
+  struct AllocatedBlock {
+    size_t size;
+    char payload[1];
+
+    static AllocatedBlock* fromPayload(void* p) {
+      return reinterpret_cast<AllocatedBlock*>(
+          // Cast to void* to silence "cast increases required alignment of
+          // target type [-Werror=cast-align]"
+          reinterpret_cast<void*>(reinterpret_cast<char*>(p) -
+                                  offsetof(AllocatedBlock, payload)));
+    }
+  };
+
+  AllocatorLog log_;
+  Allocator* upstream_;
+};
+
+class ControllableAllocator : public ArduinoJson::Allocator {
+ public:
+  ControllableAllocator(
+      Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())
+      : enabled_(true), upstream_(upstream) {}
+  virtual ~ControllableAllocator() {}
+
+  void* allocate(size_t n) override {
+    return enabled_ ? upstream_->allocate(n) : 0;
+  }
+
+  void deallocate(void* p) override {
+    upstream_->deallocate(p);
+  }
+
+  void* reallocate(void* ptr, size_t n) override {
+    return enabled_ ? upstream_->reallocate(ptr, n) : 0;
+  }
+
+  void disable() {
+    enabled_ = false;
+  }
+
+ private:
+  bool enabled_;
+  Allocator* upstream_;
+};
+
+class TimebombAllocator : public ArduinoJson::Allocator {
+ public:
+  TimebombAllocator(
+      size_t initialCountdown,
+      Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())
+      : countdown_(initialCountdown), upstream_(upstream) {}
+  virtual ~TimebombAllocator() {}
+
+  void* allocate(size_t n) override {
+    if (!countdown_)
+      return nullptr;
+    countdown_--;
+    return upstream_->allocate(n);
+  }
+
+  void deallocate(void* p) override {
+    upstream_->deallocate(p);
+  }
+
+  void* reallocate(void* ptr, size_t n) override {
+    if (!countdown_)
+      return nullptr;
+    countdown_--;
+    return upstream_->reallocate(ptr, n);
+  }
+
+  void setCountdown(size_t value) {
+    countdown_ = value;
+  }
+
+ private:
+  size_t countdown_ = 0;
+  Allocator* upstream_;
+};

extras/tests/Helpers/Arduino.h

@@ -0,0 +1,13 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "api/Print.h"
+#include "api/Stream.h"
+#include "api/String.h"
+#include "avr/pgmspace.h"
+
+#define ARDUINO
+#define ARDUINO_H_INCLUDED 1

extras/tests/Helpers/CustomReader.hpp

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 
 #pragma once
@@ -7,20 +7,18 @@
 #include <sstream>
 
 class CustomReader {
-  std::stringstream _stream;
+  std::stringstream stream_;
 
  public:
-  CustomReader(const char* input) : _stream(input) {}
+  CustomReader(const char* input) : stream_(input) {}
+  CustomReader(const CustomReader&) = delete;
 
   int read() {
-    return _stream.get();
+    return stream_.get();
   }
 
   size_t readBytes(char* buffer, size_t length) {
-    _stream.read(buffer, static_cast<std::streamsize>(length));
-    return static_cast<size_t>(_stream.gcount());
+    stream_.read(buffer, static_cast<std::streamsize>(length));
+    return static_cast<size_t>(stream_.gcount());
   }
-
- private:
-  CustomReader(const CustomReader&);
 };

extras/tests/Helpers/WString.h

@@ -1,42 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#pragma once
-
-#include <string>
-
-// Reproduces Arduino's String class
-class String {
- public:
-  String& operator+=(const char* rhs) {
-    _str += rhs;
-    return *this;
-  }
-
-  size_t length() const {
-    return _str.size();
-  }
-
-  const char* c_str() const {
-    return _str.c_str();
-  }
-
-  bool operator==(const char* s) const {
-    return _str == s;
-  }
-
-  friend std::ostream& operator<<(std::ostream& lhs, const ::String& rhs) {
-    lhs << rhs._str;
-    return lhs;
-  }
-
- private:
-  std::string _str;
-};
-
-class StringSumHelper;
-
-inline bool operator==(const std::string& lhs, const ::String& rhs) {
-  return lhs == rhs.c_str();
-}

extras/tests/Helpers/api/Print.h

@@ -0,0 +1,33 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+class Print {
+ public:
+  virtual ~Print() {}
+
+  virtual size_t write(uint8_t) = 0;
+  virtual size_t write(const uint8_t *buffer, size_t size) = 0;
+
+  size_t write(const char *str) {
+    if (!str)
+      return 0;
+    return write(reinterpret_cast<const uint8_t *>(str), strlen(str));
+  }
+
+  size_t write(const char *buffer, size_t size) {
+    return write(reinterpret_cast<const uint8_t *>(buffer), size);
+  }
+};
+
+class Printable {
+ public:
+  virtual ~Printable() {}
+  virtual size_t printTo(Print &p) const = 0;
+};

extras/tests/Helpers/api/Stream.h

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 
 #pragma once

extras/tests/Helpers/api/String.h

@@ -0,0 +1,69 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <string>
+
+// Reproduces Arduino's String class
+class String {
+ public:
+  String() : maxCapacity_(1024) {}
+  explicit String(const char* s) : str_(s), maxCapacity_(1024) {}
+
+  void limitCapacityTo(size_t maxCapacity) {
+    maxCapacity_ = maxCapacity;
+  }
+
+  unsigned char concat(const char* s) {
+    return concat(s, strlen(s));
+  }
+
+  size_t length() const {
+    return str_.size();
+  }
+
+  const char* c_str() const {
+    return str_.c_str();
+  }
+
+  bool operator==(const char* s) const {
+    return str_ == s;
+  }
+
+  String& operator=(const char* s) {
+    str_.assign(s);
+    return *this;
+  }
+
+  char operator[](unsigned int index) const {
+    if (index >= str_.size())
+      return 0;
+    return str_[index];
+  }
+
+  friend std::ostream& operator<<(std::ostream& lhs, const ::String& rhs) {
+    lhs << rhs.str_;
+    return lhs;
+  }
+
+ protected:
+  // This function is protected in most Arduino cores
+  unsigned char concat(const char* s, size_t n) {
+    if (str_.size() + n > maxCapacity_)
+      return 0;
+    str_.append(s, n);
+    return 1;
+  }
+
+ private:
+  std::string str_;
+  size_t maxCapacity_;
+};
+
+class StringSumHelper : public ::String {};
+
+inline bool operator==(const std::string& lhs, const ::String& rhs) {
+  return lhs == rhs.c_str();
+}

extras/tests/Helpers/avr/pgmspace.h

@@ -0,0 +1,31 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stdint.h>  // uint8_t
+
+#define PROGMEM
+
+class __FlashStringHelper;
+
+inline const void* convertPtrToFlash(const void* s) {
+  return reinterpret_cast<const char*>(s) + 42;
+}
+
+inline const void* convertFlashToPtr(const void* s) {
+  return reinterpret_cast<const char*>(s) - 42;
+}
+
+#define PSTR(X) reinterpret_cast<const char*>(convertPtrToFlash(X))
+#define F(X) reinterpret_cast<const __FlashStringHelper*>(PSTR(X))
+
+inline uint8_t pgm_read_byte(const void* p) {
+  return *reinterpret_cast<const uint8_t*>(convertFlashToPtr(p));
+}
+
+#define ARDUINOJSON_DEFINE_PROGMEM_ARRAY(type, name, ...)                \
+  static type const ARDUINOJSON_CONCAT2(name, _progmem)[] = __VA_ARGS__; \
+  static type const* name = reinterpret_cast<type const*>(               \
+      convertPtrToFlash(ARDUINOJSON_CONCAT2(name, _progmem)));

extras/tests/IntegrationTests/CMakeLists.txt

@@ -1,19 +1,24 @@
-# ArduinoJson - arduinojson.org
-# Copyright Benoit Blanchon 2014-2020
+# ArduinoJson - https://arduinojson.org
+# Copyright © 2014-2023, Benoit BLANCHON
 # MIT License
 
 add_executable(IntegrationTests
 	gbathree.cpp
 	issue772.cpp
 	round_trip.cpp
+	openweathermap.cpp
 )
 
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 6)
 	target_compile_options(IntegrationTests
 		PUBLIC
-		-fsingle-precision-constant # issue 544
+			-fsingle-precision-constant # issue 544
 	)
 endif()
 
-target_link_libraries(IntegrationTests catch)
 add_test(IntegrationTests IntegrationTests)
+
+set_tests_properties(IntegrationTests
+	PROPERTIES
+		LABELS "Catch"
+)

extras/tests/IntegrationTests/gbathree.cpp

@@ -1,12 +1,12 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
 TEST_CASE("Gbathree") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc(4096);
 
   DeserializationError error = deserializeJson(
       doc,

extras/tests/IntegrationTests/issue772.cpp

@@ -1,5 +1,5 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
@@ -8,8 +8,8 @@
 // https://github.com/bblanchon/ArduinoJson/issues/772
 
 TEST_CASE("Issue772") {
-  DynamicJsonDocument doc1(4096);
-  DynamicJsonDocument doc2(4096);
+  JsonDocument doc1(4096);
+  JsonDocument doc2(4096);
   DeserializationError err;
   std::string data =
       "{\"state\":{\"reported\":{\"timestamp\":\"2018-07-02T09:40:12Z\","