Set version to 5.1.0 beta 2

.clang-format

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

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,54 +0,0 @@
----
-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++
-DynamicJsonDocument 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

@@ -1,8 +0,0 @@
-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

@@ -1,19 +0,0 @@
----
-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

@@ -1,51 +0,0 @@
----
-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++
-DynamicJsonDocument 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/workflows/ci.yml

@@ -1,555 +0,0 @@
-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@v2
-      - 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
-
-  gcc:
-    name: GCC
-    needs: lint
-    runs-on: ubuntu-20.04
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - gcc: "4.4"
-          - gcc: "4.6"
-          - gcc: "4.7"
-          - gcc: "4.8"
-          - gcc: "4.9"
-          - 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"
-          - gcc: "11"
-    steps:
-      - name: Install
-        run: |
-          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ trusty main'
-          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ trusty universe'
-          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 add-apt-repository -yn 'deb http://mirrors.kernel.org/ubuntu hirsute main universe' 
-          sudo apt-get update
-          sudo apt-get install -y gcc-${{ matrix.gcc }} g++-${{ matrix.gcc }}
-      - name: Checkout
-        uses: actions/checkout@v2
-      - 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: ctest --output-on-failure -C Debug .
-        env:
-          UBSAN_OPTIONS: print_stacktrace=1
-
-  clang:
-    name: Clang
-    needs: lint
-    runs-on: ubuntu-20.04
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - clang: "3.5"
-            cxxflags: "-stdlib=libc++"
-          - clang: "3.6"
-            cxxflags: "-stdlib=libc++"
-          - clang: "3.7"
-            cxxflags: "-stdlib=libc++"
-          - 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/ trusty main'
-          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ trusty universe'
-          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@v2
-      - 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: ctest --output-on-failure -C Debug .
-        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 install -y g++-multilib
-      - name: Checkout
-        uses: actions/checkout@v2
-      - 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@v2
-      - 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-10.15
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - xcode: "10.3"
-          - xcode: "11.7"
-          - xcode: "12.4"
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - 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@v2
-  #     - 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@v2
-      - name: Install arduino-cli
-        run: brew update && brew install arduino-cli
-      - 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@v2
-      - name: Set up cache for pip
-        uses: actions/cache@v2
-        with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip
-      - name: Set up Python 3.x
-        uses: actions/setup-python@v2
-        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@v2
-        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@v2
-      - 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@v2
-      - 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@v2
-      - 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@v2
-        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 install -y valgrind ninja-build
-      - name: Checkout
-        uses: actions/checkout@v2
-      - 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@v2
-      - 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@v2
-      - 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 ::set-output name=filename::${OUTPUT}
-      - name: Smoke test
-        run: |
-          g++ -x c++ - <<END
-          #include "${{ steps.amalgamate.outputs.filename }}"
-          int main() {
-            StaticJsonDocument<300> doc;
-            deserializeJson(doc, "{}");
-          }
-          END
-      - name: Upload artifact
-        uses: actions/upload-artifact@v2
-        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@v2
-      - 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 ::set-output name=filename::${OUTPUT}
-      - name: Smoke test
-        run: |
-          g++ -x c++ - <<END
-          #include "${{ steps.amalgamate.outputs.filename }}"
-          int main() {
-            ArduinoJson::StaticJsonDocument<300> doc;
-            deserializeJson(doc, "{}");
-          }
-          END
-      - name: Upload artifact
-        uses: actions/upload-artifact@v2
-        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@v2
-        with:
-          path: ~/.espressif
-          key: ${{ runner.os }}-esp-idf
-      - name: Checkout ArduinoJson
-        uses: actions/checkout@v2
-      - name: Checkout ESP-IDF
-        uses: actions/checkout@v2
-        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

.github/workflows/lock.yml

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

.github/workflows/release.yml

@@ -1,51 +0,0 @@
-name: Release
-
-on:
-  push:
-    tags:
-      - v*.*.*
-
-jobs:
-  release:
-    name: Create release
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Set variables
-        id: init
-        run: |
-          echo ::set-output name=tag::${GITHUB_REF#refs/tags/}
-          echo ::set-output name=version::${GITHUB_REF#refs/tags/v}
-      - name: Checkout
-        uses: actions/checkout@v2
-      - 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 ::set-output name=filename::$FILENAME
-      - 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 ::set-output name=filename::$FILENAME
-      - 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 ::set-output name=filename::$FILENAME
-      - name: Create Arduino package
-        id: arduino
-        run: |
-          FILENAME=ArduinoJson-${{ steps.init.outputs.tag }}.zip
-          extras/scripts/build-arduino-package.sh . "$FILENAME"
-          echo ::set-output name=filename::$FILENAME
-      - name: Create release
-        uses: ncipollo/release-action@v1
-        with:
-          bodyFile: ${{ steps.body.outputs.filename }}
-          draft: true
-          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 }}

.gitignore

@@ -6,12 +6,3 @@
 /sftp-config.json
 .tags
 .tags_sorted_by_file
-/extras/fuzzing/*_fuzzer
-/extras/fuzzing/*_fuzzer.options
-/extras/fuzzing/*_fuzzer_seed_corpus.zip
-.vs/
-/out/
-
-# Used by CI for Particle
-/src/*.ino
-/project.properties

.mbedignore

@@ -1,3 +0,0 @@
-.github/
-examples/
-extras/

.prettierignore

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

.travis.yml

@@ -0,0 +1,15 @@
+sudo: false
+language: cpp
+cache:
+  directories:
+    - "~/.platformio"
+env:
+  - COMPILER=gcc
+  - COMPILER=clang
+  - COMPILER=arduino VERSION=1.5.8 BOARD=arduino:avr:uno
+  - COMPILER=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
+  - COMPILER=platformio BOARD=uno
+  - COMPILER=platformio BOARD=due
+  - COMPILER=platformio BOARD=esp01
+  - COMPILER=platformio BOARD=teensy31
+script: scripts/travis/$COMPILER.sh

.vscode/settings.json

@@ -1,22 +0,0 @@
-{
-  "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools",
-  "cmake.generator": "Ninja",
-  "git.inputValidationLength": 80,
-  "git.inputValidationSubjectLength": 72,
-  "files.insertFinalNewline": true,
-  "files.trimFinalNewlines": true,
-  "files.associations": {
-    "fstream": "cpp",
-    "iomanip": "cpp",
-    "string": "cpp",
-    "system_error": "cpp",
-    "vector": "cpp",
-    "xlocmon": "cpp",
-    "xlocnum": "cpp",
-    "xloctime": "cpp",
-    "xstring": "cpp"
-  },
-  "search.exclude": {
-    "/extras/tests/catch/*": true
-  }
-}

ArduinoJson.h

@@ -1,5 +1,14 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
-#include "src/ArduinoJson.h"
+// About this file
+// ---------------
+// This file is here for [PlatformIO](http://platformio.org/).
+// It must be present in the root for the tool to find it.
+// Feel free to ignore this file if your working in another environment.
+
+#include "include/ArduinoJson.h"

CHANGELOG.md

@@ -1,757 +1,239 @@
 ArduinoJson: change log
 =======================
 
-v6.19.0 (2022-01-08)
--------
-
-* Remove `ARDUINOJSON_EMBEDDED_MODE` and assume we run on an embedded platform.  
-  Dependent settings (like `ARDUINOJSON_DEFAULT_NESTING_LIMIT`) must be set individually.
-* Change the default of `ARDUINOJSON_USE_DOUBLE` to `1`
-* Change the default of `ARDUINOJSON_USE_LONG_LONG` to `1` on 32-bit platforms
-* Add `as<JsonString>()` and `is<JsonString>()`
-* Add safe bool idiom in `JsonString`
-* Add support for NUL in string values (issue #1646)
-* Add support for arbitrary array rank in `copyArray()`
-* Add support for `char[][]` in `copyArray()`
-* Remove `DeserializationError == bool` and `DeserializationError != bool`
-* Renamed undocumented function `isUndefined()` to `isUnbound()`
-* Fix `JsonVariant::memoryUsage()` for raw strings
-* Fix `call of overloaded 'swap(BasicJsonDocument&, BasicJsonDocument&)' is ambiguous` (issue #1678)
-* Fix inconsistent pool capacity between `BasicJsonDocument`'s copy and move constructors
-* Fix inconsistent pool capacity between `BasicJsonDocument`'s copy and move assignments
-* Fix return type of `StaticJsonDocument::operator=`
-* Avoid pool reallocation in `BasicJsonDocument`'s copy assignment if capacity is the same
-* Avoid including `Arduino.h` when all its features are disabled (issue #1692, PR #1693 by @paulocsanz)
-* Assume `PROGMEM` is available as soon as `ARDUINO` is defined (consequence of #1693)
-
-
-v6.18.5 (2021-09-28)
--------
-
-* Set `ARDUINOJSON_EMBEDDED_MODE` to `1` on Nios II (issue #1657)
-
-v6.18.4 (2021-09-06)
--------
-
-* Fixed error `'dummy' may be used uninitialized` on GCC 11
-* Fixed error `expected unqualified-id before 'const'` on GCC 11 (issue #1622)
-* Filter: exact match takes precedence over wildcard (issue #1628)
-* Fixed deserialization of `\u0000` (issue #1646)
-
-v6.18.3 (2021-07-27)
--------
-
-* Changed return type of `convertToJson()` and `Converter<T>::toJson()` to `void`
-* Added `as<std::string_view>()` and `is<std::string_view>()`
-
-v6.18.2 (2021-07-19)
--------
-
-* Removed a symlink because the Arduino Library Specification forbids it
-
-v6.18.1 (2021-07-03)
--------
-
-* Fixed support for `volatile float` and `volatile double` (issue #1557)
-* Fixed error `[Pe070]: incomplete type is not allowed` on IAR (issue #1560)
-* Fixed `serializeJson(doc, String)` when allocation fails (issue #1572)
-* Fixed clang-tidy warnings (issue #1574, PR #1577 by @armandas)
-* Added fake class `InvalidConversion<T1,T2>` to easily identify invalid conversions (issue #1585)
-* Added support for `std::string_view` (issue #1578, PR #1554 by @0xFEEDC0DE64)
-* Fixed warning `definition of implicit copy constructor for 'MsgPackDeserializer' is deprecated because it has a user-declared copy assignment operator`
-* Added `JsonArray::clear()` (issue #1597)
-* Fixed `JsonVariant::as<unsigned>()` (issue #1601)
-* Added support for ESP-IDF component build (PR #1562 by @qt1, PR #1599 by @andreaskuster)
-
-v6.18.0 (2021-05-05)
--------
-
-* Added support for custom converters (issue #687)
-* Added support for `Printable` (issue #1444)
-* Removed support for `char` values, see below (issue #1498)
-* `deserializeJson()` leaves `\uXXXX` unchanged instead of returning `NotSupported`
-* `deserializeMsgPack()` inserts `null` instead of returning `NotSupported`
-* Removed `DeserializationError::NotSupported`
-* Added `JsonVariant::is<JsonArrayConst/JsonObjectConst>()` (issue #1412)
-* Added `JsonVariant::is<JsonVariant/JsonVariantConst>()` (issue #1412)
-* Changed `JsonVariantConst::is<JsonArray/JsonObject>()` to return `false` (issue #1412)
-* Simplified `JsonVariant::as<T>()` to always return `T` (see below)
-* Updated folders list in `.mbedignore` (PR #1515 by @AGlass0fMilk)
-* Fixed member-call-on-null-pointer in `getMember()` when array is empty
-* `serializeMsgPack(doc, buffer, size)` doesn't add null-terminator anymore (issue #1545)
-* `serializeJson(doc, buffer, size)` adds null-terminator only if there is enough room
-* PlatformIO: set `build.libArchive` to `false` (PR #1550 by @askreet)
-
-> ### BREAKING CHANGES
->
-> #### Support for `char` removed
->
-> We cannot cast a `JsonVariant` to a `char` anymore, so the following will break:
-> ```c++
-> char age = doc["age"];  //  error: no matching function for call to 'variantAs(VariantData*&)'
-> ```
-> Instead, you must use another integral type, such as `int8_t`:
-> ```c++
-> int8_t age = doc["age"];  // OK
-> ```
->
-> Similarly, we cannot assign from a `char` anymore, so the following will break:
-> ```c++
-> char age;
-> doc["age"] = age;  // error: no matching function for call to 'VariantRef::set(const char&)'
-> ```
-> Instead, you must use another integral type, such as `int8_t`:
-> ```c++
-> int8_t age;
-> doc["age"] = age;  // OK
-> ```
-> A deprecation warning with the message "Support for `char` is deprecated, use `int8_t` or `uint8_t` instead" was added to allow a smooth transition.
->
-> #### `as<T>()` always returns `T`
->
-> Previously, `JsonVariant::as<T>()` could return a type different from `T`.
-> The most common example is `as<char*>()` that returned a `const char*`.
-> While this feature simplified a few use cases, it was confusing and complicated the
-> implementation of custom converters.
->
-> Starting from this version, `as<T>` doesn't try to auto-correct the return type and always return `T`,
-> which means that you cannot write this anymore:
->
-> ```c++
-> Serial.println(doc["sensor"].as<char*>());  // error: invalid conversion from 'const char*' to 'char*' [-fpermissive]
-> ```
-> 
-> Instead, you must write:
->
-> ```c++
-> Serial.println(doc["sensor"].as<const char*>());  // OK
-> ```
->
-> A deprecation warning with the message "Replace `as<char*>()` with `as<const char*>()`" was added to allow a smooth transition.
->
-> #### `DeserializationError::NotSupported` removed
->
-> On a different topic, `DeserializationError::NotSupported` has been removed.
-> Instead of returning this error:
->
-> * `deserializeJson()` leaves `\uXXXX` unchanged (only when `ARDUINOJSON_DECODE_UNICODE` is `0`)
-> * `deserializeMsgPack()` replaces unsupported values with `null`s
->
-> #### Const-aware `is<T>()`
->
-> Lastly, a very minor change concerns `JsonVariantConst::is<T>()`.
-> It used to return `true` for `JsonArray` and `JsonOject`, but now it returns `false`.
-> Instead, you must use `JsonArrayConst` and `JsonObjectConst`.
-
-v6.17.3 (2021-02-15)
--------
-
-* Made `JsonDocument`'s destructor protected (issue #1480)
-* Added missing calls to `client.stop()` in `JsonHttpClient.ino` (issue #1485)
-* Fixed error `expected ')' before 'char'` when `isdigit()` is a macro (issue #1487)
-* Fixed error `definition of implicit copy constructor is deprecated` on Clang 10
-* PlatformIO: set framework compatibility to `*` (PR #1490 by @maxgerhardt)
-
-v6.17.2 (2020-11-14)
--------
-
-* Fixed invalid conversion error in `operator|(JsonVariant, char*)` (issue #1432)
-* Changed the default value of `ARDUINOJSON_ENABLE_PROGMEM` (issue #1433).
-  It now checks that the `pgm_read_XXX` macros are defined before enabling `PROGMEM`.
-
-v6.17.1 (2020-11-07)
--------
-
-* Fixed error `ambiguous overload for 'operator|'` (issue #1411)
-* Fixed `operator|(MemberProxy, JsonObject)` (issue #1415)
-* Allowed more than 32767 values in non-embedded mode (issue #1414)
-
-v6.17.0 (2020-10-19)
--------
-
-* Added a build failure when nullptr is defined as a macro (issue #1355)
-* Added `JsonDocument::overflowed()` which tells if the memory pool was too small (issue #1358)
-* Added `DeserializationError::EmptyInput` which tells if the input was empty
-* Added `DeserializationError::f_str()` which returns a `const __FlashStringHelper*` (issue #846)
-* Added `operator|(JsonVariantConst, JsonVariantConst)`
-* Added filtering for MessagePack (issue #1298, PR #1394 by Luca Passarella)
-* Moved float convertion tables to PROGMEM
-* Fixed `JsonVariant::set((char*)0)` which returned false instead of true (issue #1368)
-* Fixed error `No such file or directory #include <WString.h>` (issue #1381)
-
-v6.16.1 (2020-08-04)
--------
-
-* Fixed `deserializeJson()` that stopped reading after `{}` (issue #1335)
-
-v6.16.0 (2020-08-01)
--------
-
-* Added comparisons (`>`, `>=`, `==`, `!=`, `<`, and `<=`) between `JsonVariant`s
-* Added string deduplication (issue #1303)
-* Added `JsonString::operator!=`
-* Added wildcard key (`*`) for filters (issue #1309)
-* Set `ARDUINOJSON_DECODE_UNICODE` to `1` by default
-* Fixed `copyArray()` not working with `String`, `ElementProxy`, and `MemberProxy`
-* Fixed error `getOrAddElement is not a member of ElementProxy` (issue #1311)
-* Fixed excessive stack usage when compiled with `-Og` (issues #1210 and #1314)
-* Fixed `Warning[Pa093]: implicit conversion from floating point to integer` on IAR compiler (PR #1328 by @stawiski)
-
-v6.15.2 (2020-05-15)
--------
-
-* CMake: don't build tests when imported in another project
-* CMake: made project arch-independent
-* Visual Studio: fixed error C2766 with flag `/Zc:__cplusplus` (issue #1250)
-* Added support for `JsonDocument` to `copyArray()` (issue #1255)
-* Added support for `enum`s in `as<T>()` and `is<T>()`  (issue #1256)
-* Added `JsonVariant` as an input type for `deserializeXxx()`  
-  For example, you can do: `deserializeJson(doc2, doc1["payload"])`
-* Break the build if using 64-bit integers with ARDUINOJSON_USE_LONG_LONG==0
-
-v6.15.1 (2020-04-08)
--------
-
-* Fixed "maybe-uninitialized" warning (issue #1217)
-* Fixed "statement is unreachable" warning on IAR (issue #1233)
-* Fixed "pointless integer comparison" warning on IAR (issue #1233)
-* Added CMake "install" target (issue #1209)
-* Disabled alignment on AVR (issue #1231)
-
-v6.15.0 (2020-03-22)
--------
-
-* Added `DeserializationOption::Filter` (issue #959)
-* Added example `JsonFilterExample.ino`
-* Changed the array subscript operator to automatically add missing elements
-* Fixed "deprecated-copy" warning on GCC 9 (fixes #1184)
-* Fixed `MemberProxy::set(char[])` not duplicating the string (issue #1191)
-* Fixed enums serialized as booleans (issue #1197)
-* Fixed incorrect string comparison on some platforms (issue #1198)
-* Added move-constructor and move-assignment to `BasicJsonDocument`
-* Added `BasicJsonDocument::garbageCollect()` (issue #1195)
-* Added `StaticJsonDocument::garbageCollect()`
-* Changed copy-constructor of `BasicJsonDocument` to preserve the capacity of the source.
-* Removed copy-constructor of `JsonDocument` (issue #1189)
-
-> ### BREAKING CHANGES
-> 
-> #### Copy-constructor of `BasicJsonDocument`
->
-> In previous versions, the copy constructor of `BasicJsonDocument` looked at the source's `memoryUsage()` to choose its capacity.
-> Now, the copy constructor of `BasicJsonDocument` uses the same capacity as the source.
->
-> Example:
->
-> ```c++
-> DynamicJsonDocument doc1(64);
-> doc1.set(String("example"));
->
-> DynamicJsonDocument doc2 = doc1;
-> Serial.print(doc2.capacity());  // 8 with ArduinoJson 6.14
->                                 // 64 with ArduinoJson 6.15
-> ```
->
-> I made this change to get consistent results between copy-constructor and move-constructor, and whether RVO applies or not.
->
-> If you use the copy-constructor to optimize your documents, you can use `garbageCollect()` or `shrinkToFit()` instead.
->
-> #### Copy-constructor of `JsonDocument`
->
-> In previous versions, it was possible to create a function that take a `JsonDocument` by value.
->
-> ```c++
-> void myFunction(JsonDocument doc) {}
-> ```
->
-> This function gives the wrong clues because it doesn't receive a copy of the `JsonDocument`, only a sliced version.
-> It worked because the copy constructor copied the internal pointers, but it was an accident.
->
-> From now, if you need to pass a `JsonDocument` to a function, you must use a reference:
->
-> ```c++
-> void myFunction(JsonDocument& doc) {}
-> ```
-
-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)
+v5.1.0
 ------
 
-* 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"
+* Added support of `long long` (issue #171)
+* Moved all build settings to `ArduinoJson/Configuration.hpp`
 
-v6.9.0 (2019-02-26)
+**BREAKING CHANGE**:
+If you defined `ARDUINOJSON_ENABLE_STD_STREAM`, you now need to define it to `1`.
+
+v5.0.8
 ------
 
-* 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()`
+* Made the library compatible with [PlatformIO](http://platformio.org/) (issue #181)
+* Fixed `JsonVariant::is<bool>()` that was incorrectly returning false (issue #214)
 
-v6.8.0-beta (2019-01-30)
------------
+v5.0.7
+------
 
-* 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
+* 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
-> 
-> #### `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));
-> ```
+**BREAKING CHANGES**:
+- `JsonVariant(true).as<String>()` now returns `"true"` instead of `"1"`
+- `JsonVariant(false).as<String>()` now returns `"false"` instead of `"0"`
 
-v6.7.0-beta (2018-12-07)
------------
+v5.0.6
+------
 
-* 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
+* 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)
 
-v6.6.0-beta (2018-11-13)
------------
+v5.0.5
+------
 
-* 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)
+* Added overload `JsonObjectSuscript::set(value, decimals)` (issue #143)
+* Use `float` instead of `double` to reduce the size of `JsonVariant` (issue #134)
 
-v6.5.0-beta (2018-10-13)
------------
+v5.0.4
+------
 
-* 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)
+* Fixed ambiguous overload with `JsonArraySubscript` and `JsonObjectSubscript` (issue #122)
 
-v6.4.0-beta (2018-09-11)
------------
+v5.0.3
+------
 
-* Copy `JsonArray` and `JsonObject`, instead of storing pointers (issue #780)
-* Added `JsonVariant::to<JsonArray>()` and `JsonVariant::to<JsonObject>()`
+* Fixed `printTo(String)` which wrote numbers instead of strings (issue #120)
+* Fixed return type of `JsonArray::is<T>()` and some others (issue #121)
 
-v6.3.0-beta (2018-08-31)
------------
+v5.0.2
+------
 
-* Implemented reference semantics for `JsonVariant`
-* Replaced `JsonPair`'s `key` and `value` with `key()` and `value()`
-* Fixed `serializeJson(obj[key], dst)` (issue #794)
+* 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)
 
-> ### 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!
+v5.0.1
+------
 
-v6.2.3-beta (2018-07-19)
------------
+* Fixed compilation with Arduino 1.0.6 (issue #99)
 
-* Fixed exception when using Flash strings as object keys (issue #784)
+v5.0.0
+------
 
-v6.2.2-beta (2018-07-18)
------------
+* 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)
 
-* Fixed `invalid application of 'sizeof' to incomplete type '__FlashStringHelper'` (issue #783)
-* Fixed `char[]` not duplicated when passed to `JsonVariant::operator[]`
+**BREAKING CHANGES**:
+- `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()`
 
-v6.2.1-beta (2018-07-17)
------------
+**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!
 
-* Fixed `JsonObject` not inserting keys of type `String` (issue #782)
+v4.6
+----
 
-v6.2.0-beta (2018-07-12)
------------
+* Fixed segmentation fault in `DynamicJsonBuffer` when memory allocation fails (issue #92)
 
-* 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()`
+v4.5
+----
 
-> ### 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]");
-> ```
+* Fixed buffer overflow when input contains a backslash followed by a terminator (issue #81)
 
-v6.1.0-beta (2018-07-02)
------------
+**Upgrading is recommended** since previous versions contain a potential security risk.
 
-* Return `JsonArray` and `JsonObject` by value instead of reference (issue #309)
-* Replaced `success()` with `isNull()`
+Special thanks to [Giancarlo Canales Barreto](https://github.com/gcanalesb) for finding this nasty bug.
 
-> ### 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;
-> }
-> ```
+v4.4
+----
 
-v6.0.1-beta (2018-06-11)
------------
+* Added `JsonArray::measureLength()` and `JsonObject::measureLength()` (issue #75)
 
-* Fixed conflicts with `isnan()` and `isinf()` macros (issue #752)
+v4.3
+----
 
-v6.0.0-beta (2018-06-07)
------------
+* Added `JsonArray::removeAt()` to remove an element of an array (issue #58)
+* Fixed stack-overflow in `DynamicJsonBuffer` when parsing huge JSON files (issue #65)
+* Fixed wrong return value of `parseArray()` and `parseObject()` when allocation fails (issue #68)
 
-* 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
+v4.2
+----
 
-> ### 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);
-> ```
+* Switched back to old library layout (issues #39, #43 and #45)
+* Removed global new operator overload (issue #40, #45 and #46)
+* Added an example with EthernetServer
+
+v4.1
+----
+
+* Added DynamicJsonBuffer (issue #19)
+
+v4.0
+----
+
+* Unified parser and generator API (issue #23)
+* Updated library layout, now requires Arduino 1.0.6 or newer
+
+**BREAKING CHANGE**: API changed significantly, see [Migrating code to the new API](https://github.com/bblanchon/ArduinoJson/wiki/Migrating-code-to-the-new-API).
+
+
+v3.4
+----
+
+* Fixed escaped char parsing (issue #16)
+
+
+v3.3
+----
+
+* Added indented output for the JSON generator (issue #11), see example bellow.
+* Added `IndentedPrint`, a decorator for `Print` to allow indented output
+
+Example:
+
+    JsonOject<2> json;
+    json["key"] = "value";
+    json.prettyPrintTo(Serial);
+
+v3.2
+----
+
+* Fixed a bug when adding nested object in `JsonArray` (bug introduced in v3.1).
+
+v3.1
+----
+
+* Calling `Generator::JsonObject::add()` twice with the same `key` now replaces the `value`
+* Added `Generator::JsonObject::operator[]`, see bellow the new API
+* Added `Generator::JsonObject::remove()` (issue #9)
+
+Old generator API:
+
+	JsonObject<3> root; 
+    root.add("sensor", "gps");
+    root.add("time", 1351824120);
+    root.add("data", array);
+
+New generator API:
+
+	JsonObject<3> root; 
+    root["sensor"] = "gps";
+    root["time"] = 1351824120;
+    root["data"] = array;
+
+v3.0
+----
+
+* New parser API, see bellow
+* Renamed `JsonHashTable` into `JsonObject`
+* Added iterators for `JsonArray` and `JsonObject` (issue #4)
+
+Old parser API:
+
+    JsonHashTable root = parser.parseHashTable(json);
+
+	char*  sensor    = root.getString("sensor");
+	long   time      = root.getLong("time");
+	double latitude  = root.getArray("data").getDouble(0);
+    double longitude = root.getArray("data").getDouble(1);
+
+New parser API:
+
+	JsonObject root = parser.parse(json);
+
+	char*  sensor    = root["sensor"];
+    long   time      = root["time"];
+    double latitude  = root["data"][0];
+    double longitude = root["data"][1];
+
+v2.1
+----
+
+* Fixed case `#include "jsmn.cpp"` which caused an error in Linux (issue #6)
+* Fixed a buffer overrun in JSON Parser (issue #5)
+
+v2.0
+----
+
+* Added JSON encoding (issue #2)
+* Renamed the library `ArduinoJsonParser` becomes `ArduinoJson`
+
+**Breaking change**: you need to add the following line at the top of your program.
+
+	using namespace ArduinoJson::Parser;
+
+v1.2
+----
+
+* Fixed error in JSON parser example (issue #1)
+
+v1.1
+----
+
+* Example: changed `char* json` into `char[] json` so that the bytes are not write protected
+* Fixed parsing bug when the JSON contains multi-dimensional arrays
+
+v1.0 
+----
+
+Initial release

CMakeLists.txt

@@ -1,25 +1,22 @@
-# ArduinoJson - https://arduinojson.org
-# Copyright © 2014-2022, Benoit BLANCHON
+# Copyright Benoit Blanchon 2014-2016
 # MIT License
+# 
+# Arduino JSON library
+# https://github.com/bblanchon/ArduinoJson
+# If you like this project, please add a star!
 
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 2.8.12)
+project(ArduinoJson)
 
-if(ESP_PLATFORM)
-   # Build ArduinoJson as an ESP-IDF component
-   idf_component_register(INCLUDE_DIRS src)
-   return()
-endif()
+enable_testing()
 
-project(ArduinoJson VERSION 6.19.0)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/lib)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/lib)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
 
-if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
-    include(CTest)
+if(${COVERAGE})
+	set(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
 endif()
 
 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()
+add_subdirectory(test)

CONTRIBUTING.md

@@ -1,10 +0,0 @@
-# Contribution to ArduinoJson
-
-First, thank you for taking the time to contribute to this project.
-
-You can submit changes via GitHub Pull Requests.
-
-Please:
-
-1. Update the test suite for any change of behavior
-2. Use clang-format in "file" mode to format the code

LICENSE.md

@@ -1,7 +1,7 @@
 The MIT License (MIT)
 ---------------------
 
-Copyright © 2014-2022, Benoit BLANCHON
+Copyright © 2014-2016 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:
 

README.md

@@ -1,162 +1,121 @@
-![ArduinoJson](banner.svg)
+Arduino JSON library
+====================
 
----
+[![Build status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/master?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/master) [![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=master)](https://travis-ci.org/bblanchon/ArduinoJson) [![Coverage Status](https://img.shields.io/coveralls/bblanchon/ArduinoJson.svg)](https://coveralls.io/r/bblanchon/ArduinoJson?branch=master) [![Star this project](http://githubbadges.com/star.svg?user=bblanchon&repo=ArduinoJson&style=flat&color=fff&background=007ec6)](https://github.com/bblanchon/ArduinoJson)
 
-[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/bblanchon/ArduinoJson/Continuous%20Integration?logo=github)](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22+branch%3A6.x)
-[![Continuous Integration](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/6.x?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/6.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)
-[![LGTM Grade](https://img.shields.io/lgtm/grade/cpp/github/bblanchon/ArduinoJson?label=quality&logo=lgtm)](https://lgtm.com/projects/g/bblanchon/ArduinoJson/)
-[![Coveralls branch](https://img.shields.io/coveralls/github/bblanchon/ArduinoJson/6.x?logo=coveralls)](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x)  
-[![Arduino Library Manager](https://img.shields.io/static/v1?label=Arduino&message=v6.19.0&logo=arduino&logoColor=white&color=blue)](https://www.ardu-badge.com/ArduinoJson/6.19.0)
-[![PlatformIO Registry](https://badges.registry.platformio.org/packages/bblanchon/library/ArduinoJson.svg?version=6.19.0)](https://registry.platformio.org/packages/libraries/bblanchon/ArduinoJson?version=6.19.0) 
-[![GitHub stars](https://img.shields.io/github/stars/bblanchon/ArduinoJson?style=flat&logo=github)](https://github.com/bblanchon/ArduinoJson/stargazers)
-[![GitHub Sponsors](https://img.shields.io/github/sponsors/bblanchon?logo=github)](https://github.com/sponsors/bblanchon)
+*An elegant and efficient JSON library for embedded systems.*
 
-ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).
+It's designed to have the most intuitive API, the smallest footprint and works without any allocation on the heap (no malloc).
 
-## Features
+It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
 
-* [JSON deserialization](https://arduinojson.org/v6/api/json/deserializejson/?utm_source=github&utm_medium=readme)
-    * [Optionally decodes UTF-16 escape sequences to UTF-8](https://arduinojson.org/v6/api/config/decode_unicode/?utm_source=github&utm_medium=readme)
-    * [Optionally stores links to the input buffer (zero-copy)](https://arduinojson.org/v6/api/json/deserializejson/?utm_source=github&utm_medium=readme)
-    * [Optionally supports comments in the input](https://arduinojson.org/v6/api/config/enable_comments/?utm_source=github&utm_medium=readme)
-    * [Optionally filters the input to keep only desired values](https://arduinojson.org/v6/api/json/deserializejson/?utm_source=github&utm_medium=readme#filtering)
-    * Supports single quotes as a string delimiter
-    * Compatible with [NDJSON](http://ndjson.org/) and [JSON Lines](https://jsonlines.org/)
-* [JSON serialization](https://arduinojson.org/v6/api/json/serializejson/?utm_source=github&utm_medium=readme)
-    * [Can write to a buffer or a stream](https://arduinojson.org/v6/api/json/serializejson/?utm_source=github&utm_medium=readme)
-    * [Optionally indents the document (prettified JSON)](https://arduinojson.org/v6/api/json/serializejsonpretty/?utm_source=github&utm_medium=readme)
-* [MessagePack serialization](https://arduinojson.org/v6/api/msgpack/serializemsgpack/?utm_source=github&utm_medium=readme)
-* [MessagePack deserialization](https://arduinojson.org/v6/api/msgpack/deserializemsgpack/?utm_source=github&utm_medium=readme)
-* Efficient
-    * [Twice smaller than the "official" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/?utm_source=github&utm_medium=readme)
-    * [Almost 10% faster than the "official" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/?utm_source=github&utm_medium=readme)
-    * [Consumes roughly 10% less RAM than the "official" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/?utm_source=github&utm_medium=readme)
-    * [Fixed memory allocation, no heap fragmentation](https://arduinojson.org/v6/api/jsondocument/?utm_source=github&utm_medium=readme)
-    * [Optionally works without heap memory (zero malloc)](https://arduinojson.org/v6/api/staticjsondocument/?utm_source=github&utm_medium=readme)
-    * [Deduplicates strings](https://arduinojson.org/news/2020/08/01/version-6-16-0/?utm_source=github&utm_medium=readme)
-* Versatile
-    * Supports [custom allocators (to use external RAM chip, for example)](https://arduinojson.org/v6/how-to/use-external-ram-on-esp32/?utm_source=github&utm_medium=readme)
-    * Supports [`String`](https://arduinojson.org/v6/api/config/enable_arduino_string/?utm_source=github&utm_medium=readme), [`std::string`](https://arduinojson.org/v6/api/config/enable_std_string/?utm_source=github&utm_medium=readme), and [`std::string_view`](https://arduinojson.org/v6/api/config/enable_string_view/?utm_source=github&utm_medium=readme)
-    * Supports [`Stream`](https://arduinojson.org/v6/api/config/enable_arduino_stream/?utm_source=github&utm_medium=readme) and [`std::istream`/`std::ostream`](https://arduinojson.org/v6/api/config/enable_std_stream/?utm_source=github&utm_medium=readme)
-    * Supports [Flash strings](https://arduinojson.org/v6/api/config/enable_progmem/?utm_source=github&utm_medium=readme)
-    * Supports [custom readers](https://arduinojson.org/v6/api/json/deserializejson/?utm_source=github&utm_medium=readme#custom-reader) and [custom writers](https://arduinojson.org/v6/api/json/serializejson/?utm_source=github&utm_medium=readme#custom-writer)
-    * Supports [custom converters](https://arduinojson.org/news/2021/05/04/version-6-18-0/?utm_source=github&utm_medium=readme)
-* Portable
-    * Usable on any C++ project (not limited to Arduino)
-    * Compatible with C++98, C++11, C++14 and C++17
-    * 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)
-        * 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/)
-        * [Atollic TrueSTUDIO](https://atollic.com/truestudio/)
-        * [Energia](http://energia.nu/)
-        * [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/RlZSKy17DjJ6HcdN)
-    * [CMake friendly](https://arduinojson.org/v6/how-to/use-arduinojson-with-cmake/?utm_source=github&utm_medium=readme)
-* Well designed
-    * [Elegant API](http://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme)
-    * [Thread-safe](https://en.wikipedia.org/wiki/Thread_safety)
-    * Self-contained (no external dependency)
-    * `const` friendly
-    * [`for` friendly](https://arduinojson.org/v6/api/jsonobject/begin_end/?utm_source=github&utm_medium=readme)
-    * [TMP friendly](https://en.wikipedia.org/wiki/Template_metaprogramming)
-    * Handles [integer overflows](https://arduinojson.org/v6/api/jsonvariant/as/?utm_source=github&utm_medium=readme#integer-overflows)
-* Well tested
-    * [Unit test coverage close to 100%](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x)
-    * Continuously tested on
-        * [Visual Studio 2010, 2012, 2013, 2015, 2017, 2019, 2022](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, 9, 10, 11](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22)
-        * [Clang 3.5, 3.6, 3.7, 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/?utm_source=github&utm_medium=readme)
-    * [Examples](https://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme)
-    * [How-tos](https://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme)
-    * [FAQ](https://arduinojson.org/v6/faq/?utm_source=github&utm_medium=readme)
-    * [Troubleshooter](https://arduinojson.org/v6/troubleshooter/?utm_source=github&utm_medium=readme)
-    * [Book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme)
-    * [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)
-    * [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)
-    * [Discord server](https://discord.gg/DzN6hHHD4h)
+Features
+--------
 
-## Quickstart
+* JSON decoding (comments are supported)
+* JSON encoding (with optional indentation)
+* Elegant API, very easy to use
+* Efficient (no malloc, nor copy)
+* Portable (written in C++98)
+* Self-contained (no external dependency)
+* Small footprint
+* MIT License
 
-### Deserialization
+Works on
+--------
 
-Here is a program that parses a JSON document with ArduinoJson.
+* All Arduino boards
+* ESP8266
+* Teensy
+* Intel Edison
+* PlatformIO
+* Energia
+* Computers (Windows, Linux, OSX...)
+
+See [FAQ: Compatibility issues](https://github.com/bblanchon/ArduinoJson/wiki/Compatibility-issues)
+
+Quick start
+-----------
+
+#### Decoding / Parsing
 
 ```c++
 char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-DynamicJsonDocument doc(1024);
-deserializeJson(doc, json);
+StaticJsonBuffer<200> jsonBuffer;
 
-const char* sensor = doc["sensor"];
-long time          = doc["time"];
-double latitude    = doc["data"][0];
-double longitude   = doc["data"][1];
+JsonObject& root = jsonBuffer.parseObject(json);
+
+const char* sensor = root["sensor"];
+long time          = root["time"];
+double latitude    = root["data"][0];
+double longitude   = root["data"][1];
 ```
 
-See the [tutorial on arduinojson.org](https://arduinojson.org/doc/decoding/?utm_source=github&utm_medium=readme)
-
-### Serialization
-
-Here is a program that generates a JSON document with ArduinoJson:
+#### Encoding / Generating
 
 ```c++
-DynamicJsonDocument doc(1024);
+StaticJsonBuffer<200> jsonBuffer;
 
-doc["sensor"] = "gps";
-doc["time"]   = 1351824120;
-doc["data"][0] = 48.756080;
-doc["data"][1] = 2.302038;
+JsonObject& root = jsonBuffer.createObject();
+root["sensor"] = "gps";
+root["time"] = 1351824120;
 
-serializeJson(doc, Serial);
+JsonArray& data = root.createNestedArray("data");
+data.add(48.756080, 6);  // 6 is the number of decimals to print
+data.add(2.302038, 6);   // if not specified, 2 digits are printed
+
+root.printTo(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)
 
-## Sponsors
+Documentation
+-------------
 
-ArduinoJson is thankful to its sponsors. Please give them a visit; they deserve it!
+The documentation is available online in the [Arduino JSON wiki](https://github.com/bblanchon/ArduinoJson/wiki)
 
-<p>
-  <a href="https://techexplorations.com/" rel="sponsored">
-    <img alt="Tech Explorations" src="https://arduinojson.org/images/2021/10/techexplorations.png" width="200">
-  </a>
-  <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>
+Testimonials
+------------
 
-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.
+From Arduino's Forum user `jflaplante`:
+> I tried aJson json-arduino before trying your library. I always ran into memory problem after a while.
+> I have no such problem so far with your library. It is working perfectly with my web services.
 
-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;⭐.
+From Arduino's Forum user `gbathree`:
+> Thanks so much - this is an awesome library!  If you want to see what we're doing with it - the project is located at www.photosynq.org.
+
+From StackOverflow user `thegreendroid`:
+> It has a really elegant, simple API and it works like a charm on embedded and Windows/Linux platforms. We recently started using this on an embedded project and I can vouch for its quality.
+
+From GitHub user `zacsketches`:
+
+> Thanks for a great library!!!
+> I've been watching you consistently develop this library over the past six months, and I used it today for a publish and subscribe architecture designed to help hobbyists move into more advanced robotics. Your library allowed me to implement remote subscription in order to facilitate multi-processor robots.
+> ArduinoJson saved me a week's worth of time!!
+
+[From Reddit user `erm_what_`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusjk8c):
+
+> This is a great library and I wouldn't be able to do the project I'm doing without it. I completely recommend it.
+
+[From Reddit user `makerhacks`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusqg7b):
+
+> I am just starting an ESP8266 clock project and now I can output JSON from my server script and interpret it painlessly.
+
+Donators
+--------
+
+Special thanks to the following persons and companies who made generous donations to the library author:
+
+* Robert Murphy
+* Surge Communications
+* Alex Scott
+* Firepick Services LLC
+* A B Doodkorte
+* Scott Smith
+* Johann Stieger
+
+---
+
+Found this library useful? Please star this project or [help me back with a donation!](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=donate%40benoitblanchon%2efr&lc=GB&item_name=Benoit%20Blanchon&item_number=Arduino%20JSON&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted) :smile:

SUPPORT.md

@@ -1,27 +0,0 @@
-# ArduinoJson Support
-
-First off, thank you very much for using ArduinoJson.
-
-We'll be very happy to help you, but first please read the following.
-
-## Before asking for help
-
-1. Read the [FAQ](https://arduinojson.org/faq/?utm_source=github&utm_medium=support)
-2. Search in the [API Reference](https://arduinojson.org/api/?utm_source=github&utm_medium=support)
-
-If you did not find the answer, please create a [new issue on GitHub](https://github.com/bblanchon/ArduinoJson/issues/new).
-
-It is OK to add a comment to a currently opened issue, but please avoid adding comments to a closed issue.
-
-## Before hitting the Submit button
-
-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!

appveyor.yml

@@ -1,37 +1,16 @@
-version: 6.19.0.{build}
+version: 5.1.0.{build}
 environment:
   matrix:
-    - 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
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      CMAKE_GENERATOR: Visual Studio 14 2015
-    - CMAKE_GENERATOR: Visual Studio 12 2013
-    - CMAKE_GENERATOR: Visual Studio 11 2012
-    - CMAKE_GENERATOR: Visual Studio 10 2010
-    - CMAKE_GENERATOR: Ninja
-      MINGW: MinGW # MinGW 32-bit 5.3.0
-    - CMAKE_GENERATOR: Ninja
-      MINGW32: i686-5.3.0-posix-dwarf-rt_v4-rev0 # MinGW-w64 5.3.0
-    - 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
+  - CMAKE_GENERATOR: Visual Studio 14 2015
+  - CMAKE_GENERATOR: Visual Studio 12 2013
+  - CMAKE_GENERATOR: Visual Studio 11 2012
+  - CMAKE_GENERATOR: Visual Studio 10 2010
+  - CMAKE_GENERATOR: MinGW Makefiles
 configuration: Debug
 before_build:
-  - 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%" .
+- 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%" .
 build_script:
-  - cmake --build . --config %CONFIGURATION%
+- cmake --build . --config %CONFIGURATION%
 test_script:
-  - ctest -C %CONFIGURATION% --output-on-failure .
+- ctest -V . 

component.mk

@@ -1 +0,0 @@
-COMPONENT_ADD_INCLUDEDIRS := src

examples/IndentedPrintExample/IndentedPrintExample.ino

@@ -0,0 +1,35 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+
+using namespace ArduinoJson::Internals;
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial) {
+    // wait serial port initialization
+  }
+
+  IndentedPrint serial(Serial);
+  serial.setTabSize(4);
+
+  serial.println("This is at indentation 0");
+  serial.indent();
+  serial.println("This is at indentation 1");
+  serial.println("This is also at indentation 1");
+  serial.indent();
+  serial.println("This is at indentation 2");
+
+  serial.unindent();
+  serial.unindent();
+  serial.println("This is back at indentation 0");
+}
+
+void loop() {
+  // not used in this example
+}

examples/JsonConfigFile/JsonConfigFile.ino

@@ -1,160 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
-// MIT License
-//
-// This example shows how to store your project configuration in a file.
-// It uses the SD library but can be easily modified for any other file-system.
-//
-// The file contains a JSON document with the following content:
-// {
-//   "hostname": "examples.com",
-//   "port": 2731
-// }
-//
-// To run this program, you need an SD card connected to the SPI bus as follows:
-// * MOSI <-> pin 11
-// * MISO <-> pin 12
-// * CLK  <-> pin 13
-// * CS   <-> pin 4
-//
-// https://arduinojson.org/v6/example/config/
-
-#include <ArduinoJson.h>
-#include <SD.h>
-#include <SPI.h>
-
-// Our configuration structure.
-//
-// Never use a JsonDocument to store the configuration!
-// A JsonDocument is *not* a permanent storage; it's only a temporary storage
-// used during the serialization phase. See:
-// https://arduinojson.org/v6/faq/why-must-i-create-a-separate-config-object/
-struct Config {
-  char hostname[64];
-  int port;
-};
-
-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) {
-  // 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 https://arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<512> doc;
-
-  // Deserialize the JSON document
-  DeserializationError error = deserializeJson(doc, file);
-  if (error)
-    Serial.println(F("Failed to read file, using default configuration"));
-
-  // Copy values from the JsonDocument to the Config
-  config.port = doc["port"] | 2731;
-  strlcpy(config.hostname,                  // <- destination
-          doc["hostname"] | "example.com",  // <- source
-          sizeof(config.hostname));         // <- destination's capacity
-
-  // Close the file (Curiously, File's destructor doesn't close the file)
-  file.close();
-}
-
-// Saves the configuration to a file
-void saveConfiguration(const char *filename, const Config &config) {
-  // Delete existing file, otherwise the configuration is appended to the file
-  SD.remove(filename);
-
-  // Open file for writing
-  File file = SD.open(filename, FILE_WRITE);
-  if (!file) {
-    Serial.println(F("Failed to create file"));
-    return;
-  }
-
-  // Allocate a temporary JsonDocument
-  // Don't forget to change the capacity to match your requirements.
-  // Use https://arduinojson.org/assistant to compute the capacity.
-  StaticJsonDocument<256> doc;
-
-  // Set the values in the document
-  doc["hostname"] = config.hostname;
-  doc["port"] = config.port;
-
-  // Serialize JSON to file
-  if (serializeJson(doc, file) == 0) {
-    Serial.println(F("Failed to write to file"));
-  }
-
-  // Close the file
-  file.close();
-}
-
-// Prints the content of a file to the Serial
-void printFile(const char *filename) {
-  // Open file for reading
-  File file = SD.open(filename);
-  if (!file) {
-    Serial.println(F("Failed to read file"));
-    return;
-  }
-
-  // Extract each characters by one by one
-  while (file.available()) {
-    Serial.print((char)file.read());
-  }
-  Serial.println();
-
-  // Close the file
-  file.close();
-}
-
-void setup() {
-  // Initialize serial port
-  Serial.begin(9600);
-  while (!Serial) continue;
-
-  // Initialize SD library
-  const int chipSelect = 4;
-  while (!SD.begin(chipSelect)) {
-    Serial.println(F("Failed to initialize SD library"));
-    delay(1000);
-  }
-
-  // Should load default config if run for the first time
-  Serial.println(F("Loading configuration..."));
-  loadConfiguration(filename, config);
-
-  // Create configuration file
-  Serial.println(F("Saving configuration..."));
-  saveConfiguration(filename, config);
-
-  // Dump config file
-  Serial.println(F("Print config file..."));
-  printFile(filename);
-}
-
-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
-// --------
-//
-// https://arduinojson.org/ contains the documentation for all the functions
-// used above. It also includes an FAQ that will help you solve any
-// serialization or deserialization problem.
-//
-// The book "Mastering ArduinoJson" contains a case study of a project that has
-// a complex configuration with nested members.
-// Contrary to this example, the project in the book uses the SPIFFS filesystem.
-// Learn more at https://arduinojson.org/book/
-// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonFilterExample/JsonFilterExample.ino

@@ -1,63 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
-// MIT License
-//
-// This example shows how to use DeserializationOpion::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
-  const __FlashStringHelper* 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
-  StaticJsonDocument<200> filter;
-  filter["list"][0]["dt"] = true;
-  filter["list"][0]["main"]["temp"] = true;
-
-  // Deserialize the document
-  StaticJsonDocument<400> doc;
-  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,54 +1,60 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
-// This example shows how to generate a JSON document with ArduinoJson.
-//
-// https://arduinojson.org/v6/example/generator/
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #include <ArduinoJson.h>
 
 void setup() {
-  // Initialize Serial port
   Serial.begin(9600);
-  while (!Serial) continue;
+  while (!Serial) {
+    // wait serial port initialization
+  }
 
-  // Allocate the JSON document
+  // Memory pool for JSON object tree.
   //
-  // Inside the brackets, 200 is the RAM allocated to this document.
-  // Don't forget to change this value to match your requirement.
-  // Use https://arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<200> doc;
+  // Inside the brackets, 200 is the size of the pool in bytes.
+  // If the JSON object is more complex, you need to increase that value.
+  StaticJsonBuffer<200> jsonBuffer;
 
-  // StaticJsonObject allocates memory on the stack, it can be
-  // replaced by DynamicJsonDocument which allocates in the heap.
+  // StaticJsonBuffer allocates memory on the stack, it can be
+  // replaced by DynamicJsonBuffer which allocates in the heap.
+  // It's simpler but less efficient.
   //
-  // DynamicJsonDocument  doc(200);
+  // DynamicJsonBuffer  jsonBuffer;
 
-  // Add values in the document
+  // Create the root of the object tree.
   //
-  doc["sensor"] = "gps";
-  doc["time"] = 1351824120;
+  // It's a reference to the JsonObject, the actual bytes are inside the
+  // JsonBuffer with all the other nodes of the object tree.
+  // Memory is freed when jsonBuffer goes out of scope.
+  JsonObject& root = jsonBuffer.createObject();
 
-  // Add an array.
+  // Add values in the object
   //
-  JsonArray data = doc.createNestedArray("data");
-  data.add(48.756080);
-  data.add(2.302038);
+  // Most of the time, you can rely on the implicit casts.
+  // In other case, you can do root.set<long>("time", 1351824120);
+  root["sensor"] = "gps";
+  root["time"] = 1351824120;
 
-  // Generate the minified JSON and send it to the Serial port.
+  // Add a nested array.
   //
-  serializeJson(doc, Serial);
-  // The above line prints:
+  // It's also possible to create the array separately and add it to the
+  // JsonObject but it's less efficient.
+  JsonArray& data = root.createNestedArray("data");
+  data.add(double_with_n_digits(48.756080, 6));
+  data.add(double_with_n_digits(2.302038, 6));
+
+  root.printTo(Serial);
+  // This prints:
   // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
 
-  // Start a new line
   Serial.println();
 
-  // Generate the prettified JSON and send it to the Serial port.
-  //
-  serializeJsonPretty(doc, Serial);
-  // The above line prints:
+  root.prettyPrintTo(Serial);
+  // This prints:
   // {
   //   "sensor": "gps",
   //   "time": 1351824120,
@@ -62,16 +68,3 @@ void setup() {
 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
-// serialization problem.
-//
-// The book "Mastering ArduinoJson" contains a tutorial on serialization.
-// It begins with a simple example, like the one above, and then adds more
-// features like serializing directly to a file or an HTTP request.
-// Learn more at https://arduinojson.org/book/
-// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonHttpClient/JsonHttpClient.ino

@@ -1,126 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, 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 https://arduinojson.org/example.json
-// Here is the expected response:
-// {
-//   "sensor": "gps",
-//   "time": 1351824120,
-//   "data": [
-//     48.756080,
-//     2.302038
-//   ]
-// }
-//
-// https://arduinojson.org/v6/example/http-client/
-
-#include <ArduinoJson.h>
-#include <Ethernet.h>
-#include <SPI.h>
-
-void setup() {
-  // Initialize Serial port
-  Serial.begin(9600);
-  while (!Serial) continue;
-
-  // Initialize Ethernet library
-  byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
-  if (!Ethernet.begin(mac)) {
-    Serial.println(F("Failed to configure Ethernet"));
-    return;
-  }
-  delay(1000);
-
-  Serial.println(F("Connecting..."));
-
-  // Connect to HTTP server
-  EthernetClient client;
-  client.setTimeout(10000);
-  if (!client.connect("arduinojson.org", 80)) {
-    Serial.println(F("Connection failed"));
-    return;
-  }
-
-  Serial.println(F("Connected!"));
-
-  // Send HTTP request
-  client.println(F("GET /example.json HTTP/1.0"));
-  client.println(F("Host: arduinojson.org"));
-  client.println(F("Connection: close"));
-  if (client.println() == 0) {
-    Serial.println(F("Failed to send request"));
-    client.stop();
-    return;
-  }
-
-  // Check HTTP status
-  char status[32] = {0};
-  client.readBytesUntil('\r', status, sizeof(status));
-  // It should be "HTTP/1.0 200 OK" or "HTTP/1.1 200 OK"
-  if (strcmp(status + 9, "200 OK") != 0) {
-    Serial.print(F("Unexpected response: "));
-    Serial.println(status);
-    client.stop();
-    return;
-  }
-
-  // Skip HTTP headers
-  char endOfHeaders[] = "\r\n\r\n";
-  if (!client.find(endOfHeaders)) {
-    Serial.println(F("Invalid response"));
-    client.stop();
-    return;
-  }
-
-  // Allocate the JSON document
-  // Use https://arduinojson.org/v6/assistant to compute the capacity.
-  const size_t capacity = JSON_OBJECT_SIZE(3) + JSON_ARRAY_SIZE(2) + 60;
-  DynamicJsonDocument doc(capacity);
-
-  // Parse JSON object
-  DeserializationError error = deserializeJson(doc, client);
-  if (error) {
-    Serial.print(F("deserializeJson() failed: "));
-    Serial.println(error.f_str());
-    client.stop();
-    return;
-  }
-
-  // Extract values
-  Serial.println(F("Response:"));
-  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);
-
-  // Disconnect
-  client.stop();
-}
-
-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
-// --------
-//
-// https://arduinojson.org/ contains the documentation for all the functions
-// used above. It also includes an FAQ that will help you solve any
-// serialization  problem.
-//
-// The book "Mastering ArduinoJson" contains a tutorial on deserialization
-// showing how to parse the response from GitHub's API. In the last chapter,
-// it shows how to parse the huge documents from OpenWeatherMap
-// and Reddit.
-// Learn more at https://arduinojson.org/book/
-// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonParserExample/JsonParserExample.ino

@@ -1,59 +1,59 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
-// This example shows how to deserialize a JSON document with ArduinoJson.
-//
-// https://arduinojson.org/v6/example/parser/
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #include <ArduinoJson.h>
 
 void setup() {
-  // Initialize serial port
   Serial.begin(9600);
-  while (!Serial) continue;
+  while (!Serial) {
+    // wait serial port initialization
+  }
 
-  // Allocate the JSON document
+  // Memory pool for JSON object tree.
   //
-  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
-  // Don't forget to change this value to match your JSON document.
-  // Use https://arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<200> doc;
+  // Inside the brackets, 200 is the size of the pool in bytes,
+  // If the JSON object is more complex, you need to increase that value.
+  StaticJsonBuffer<200> jsonBuffer;
 
-  // StaticJsonDocument<N> allocates memory on the stack, it can be
-  // replaced by DynamicJsonDocument which allocates in the heap.
+  // StaticJsonBuffer allocates memory on the stack, it can be
+  // replaced by DynamicJsonBuffer which allocates in the heap.
+  // It's simpler but less efficient.
   //
-  // DynamicJsonDocument doc(200);
+  // DynamicJsonBuffer  jsonBuffer;
 
   // JSON input string.
   //
-  // Using a char[], as shown here, enables the "zero-copy" mode. This mode uses
-  // the minimal amount of memory because the JsonDocument stores pointers to
-  // the input buffer.
-  // If you use another type of input, ArduinoJson must copy the strings from
-  // the input to the JsonDocument, so you need to increase the capacity of the
-  // JsonDocument.
+  // It's better to use a char[] as shown here.
+  // If you use a const char* or a String, ArduinoJson will
+  // have to make a copy of the input in the JsonBuffer.
   char json[] =
       "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-  // Deserialize the JSON document
-  DeserializationError error = deserializeJson(doc, json);
+  // Root of the object tree.
+  //
+  // It's a reference to the JsonObject, the actual bytes are inside the
+  // JsonBuffer with all the other nodes of the object tree.
+  // Memory is freed when jsonBuffer goes out of scope.
+  JsonObject& root = jsonBuffer.parseObject(json);
 
   // Test if parsing succeeds.
-  if (error) {
-    Serial.print(F("deserializeJson() failed: "));
-    Serial.println(error.f_str());
+  if (!root.success()) {
+    Serial.println("parseObject() failed");
     return;
   }
 
   // Fetch values.
   //
   // Most of the time, you can rely on the implicit casts.
-  // In other case, you can do doc["time"].as<long>();
-  const char* sensor = doc["sensor"];
-  long time = doc["time"];
-  double latitude = doc["data"][0];
-  double longitude = doc["data"][1];
+  // In other case, you can do root["time"].as<long>();
+  const char* sensor = root["sensor"];
+  long time = root["time"];
+  double latitude = root["data"][0];
+  double longitude = root["data"][1];
 
   // Print values.
   Serial.println(sensor);
@@ -65,16 +65,3 @@ void setup() {
 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/JsonServer/JsonServer.ino

@@ -1,117 +1,74 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
-// MIT License
-//
-// This example shows how to implement an HTTP server that sends a JSON document
-// in the response.
-// It uses the Ethernet library but can be easily adapted for Wifi.
-//
-// The JSON document contains the values of the analog and digital pins.
-// It looks like that:
-// {
-//   "analog": [0, 76, 123, 158, 192, 205],
-//   "digital": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0]
-// }
-//
-// https://arduinojson.org/v6/example/http-server/
+// Sample Arduino Json Web Server
+// Created by Benoit Blanchon.
+// Heavily inspired by "Web Server" from David A. Mellis and Tom Igoe
 
-#include <ArduinoJson.h>
-#include <Ethernet.h>
 #include <SPI.h>
+#include <Ethernet.h>
+#include <ArduinoJson.h>
 
 byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+IPAddress ip(192, 168, 0, 177);
 EthernetServer server(80);
 
-void setup() {
-  // Initialize serial port
-  Serial.begin(9600);
-  while (!Serial) continue;
-
-  // Initialize Ethernet libary
-  if (!Ethernet.begin(mac)) {
-    Serial.println(F("Failed to initialize Ethernet library"));
-    return;
+bool readRequest(EthernetClient& client) {
+  bool currentLineIsBlank = true;
+  while (client.connected()) {
+    if (client.available()) {
+      char c = client.read();
+      if (c == '\n' && currentLineIsBlank) {
+        return true;
+      } else if (c == '\n') {
+        currentLineIsBlank = true;
+      } else if (c != '\r') {
+        currentLineIsBlank = false;
+      }
+    }
   }
-
-  // Start to listen
-  server.begin();
-
-  Serial.println(F("Server is ready."));
-  Serial.print(F("Please connect to http://"));
-  Serial.println(Ethernet.localIP());
+  return false;
 }
 
-void loop() {
-  // Wait for an incomming connection
-  EthernetClient client = server.available();
+JsonObject& prepareResponse(JsonBuffer& jsonBuffer) {
+  JsonObject& root = jsonBuffer.createObject();
 
-  // Do we have a client?
-  if (!client)
-    return;
-
-  Serial.println(F("New client"));
-
-  // Read the request (we ignore the content in this example)
-  while (client.available()) client.read();
-
-  // Allocate a temporary JsonDocument
-  // Use https://arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<500> doc;
-
-  // Create the "analog" array
-  JsonArray analogValues = doc.createNestedArray("analog");
+  JsonArray& analogValues = root.createNestedArray("analog");
   for (int pin = 0; pin < 6; pin++) {
-    // Read the analog input
     int value = analogRead(pin);
-
-    // Add the value at the end of the array
     analogValues.add(value);
   }
 
-  // Create the "digital" array
-  JsonArray digitalValues = doc.createNestedArray("digital");
+  JsonArray& digitalValues = root.createNestedArray("digital");
   for (int pin = 0; pin < 14; pin++) {
-    // Read the digital input
     int value = digitalRead(pin);
-
-    // Add the value at the end of the array
     digitalValues.add(value);
   }
 
-  Serial.print(F("Sending: "));
-  serializeJson(doc, Serial);
-  Serial.println();
-
-  // Write response headers
-  client.println(F("HTTP/1.0 200 OK"));
-  client.println(F("Content-Type: application/json"));
-  client.println(F("Connection: close"));
-  client.print(F("Content-Length: "));
-  client.println(measureJsonPretty(doc));
-  client.println();
-
-  // Write JSON document
-  serializeJsonPretty(doc, client);
-
-  // Disconnect
-  client.stop();
+  return root;
 }
 
-// Performance issue?
-// ------------------
-//
-// EthernetClient is an unbuffered stream, which is not optimal for ArduinoJson.
-// See: https://arduinojson.org/v6/how-to/improve-speed/
+void writeResponse(EthernetClient& client, JsonObject& json) {
+  client.println("HTTP/1.1 200 OK");
+  client.println("Content-Type: application/json");
+  client.println("Connection: close");
+  client.println();
 
-// 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
-// serialization problem.
-//
-// The book "Mastering ArduinoJson" contains a tutorial on serialization.
-// It begins with a simple example, then adds more features like serializing
-// directly to a file or an HTTP client.
-// Learn more at https://arduinojson.org/book/
-// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤
+  json.prettyPrintTo(client);
+}
+
+void setup() {
+  Ethernet.begin(mac, ip);
+  server.begin();
+}
+
+void loop() {
+  EthernetClient client = server.available();
+  if (client) {
+    bool success = readRequest(client);
+    if (success) {
+      StaticJsonBuffer<500> jsonBuffer;
+      JsonObject& json = prepareResponse(jsonBuffer);
+      writeResponse(client, json);
+    }
+    delay(1);
+    client.stop();
+  }
+}

examples/JsonUdpBeacon/JsonUdpBeacon.ino

@@ -1,106 +1,55 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
-// MIT License
+// Send a JSON object on UDP at regular interval
 //
-// This example shows how to send a JSON document to a UDP socket.
-// At regular interval, it sends a UDP packet that contains the status of
-// analog and digital pins.
-// It looks like that:
-// {
-//   "analog": [0, 76, 123, 158, 192, 205],
-//   "digital": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0]
-// }
+// You can easily test this program with netcat:
+// $ nc -ulp 8888
 //
-// If you want to test this program, you need to be able to receive the UDP
-// packets.
-// For example, you can run netcat on your computer
-// $ ncat -ulp 8888
-// See https://nmap.org/ncat/
-//
-// https://arduinojson.org/v6/example/udp-beacon/
+// by Benoit Blanchon, MIT License 2015-2016
 
-#include <ArduinoJson.h>
-#include <Ethernet.h>
 #include <SPI.h>
+#include <Ethernet.h>
+#include <ArduinoJson.h>
 
 byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
-IPAddress remoteIp(192, 168, 0, 108);  // <- EDIT!!!!
-unsigned short remotePort = 8888;
-unsigned short localPort = 8888;
+IPAddress localIp(192, 168, 0, 177);
+IPAddress remoteIp(192, 168, 0, 109);
+unsigned int remotePort = 8888;
+unsigned localPort = 8888;
 EthernetUDP udp;
 
-void setup() {
-  // Initialize serial port
-  Serial.begin(9600);
-  while (!Serial) continue;
+JsonObject& buildJson(JsonBuffer& jsonBuffer) {
+  JsonObject& root = jsonBuffer.createObject();
 
-  // Initialize Ethernet libary
-  if (!Ethernet.begin(mac)) {
-    Serial.println(F("Failed to initialize Ethernet library"));
-    return;
+  JsonArray& analogValues = root.createNestedArray("analog");
+  for (int pin = 0; pin < 6; pin++) {
+    int value = analogRead(pin);
+    analogValues.add(value);
   }
 
-  // Enable UDP
+  JsonArray& digitalValues = root.createNestedArray("digital");
+  for (int pin = 0; pin < 14; pin++) {
+    int value = digitalRead(pin);
+    digitalValues.add(value);
+  }
+
+  return root;
+}
+
+void sendJson(JsonObject& json) {
+  udp.beginPacket(remoteIp, remotePort);
+  json.printTo(udp);
+  udp.println();
+  udp.endPacket();
+}
+
+void setup() {
+  Ethernet.begin(mac, localIp);
   udp.begin(localPort);
 }
 
 void loop() {
-  // Allocate a temporary JsonDocument
-  // Use https://arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<500> doc;
+  delay(1000);
 
-  // Create the "analog" array
-  JsonArray analogValues = doc.createNestedArray("analog");
-  for (int pin = 0; pin < 6; pin++) {
-    // Read the analog input
-    int value = analogRead(pin);
-
-    // Add the value at the end of the array
-    analogValues.add(value);
-  }
-
-  // Create the "digital" array
-  JsonArray digitalValues = doc.createNestedArray("digital");
-  for (int pin = 0; pin < 14; pin++) {
-    // Read the digital input
-    int value = digitalRead(pin);
-
-    // Add the value at the end of the array
-    digitalValues.add(value);
-  }
-
-  // Log
-  Serial.print(F("Sending to "));
-  Serial.print(remoteIp);
-  Serial.print(F(" on port "));
-  Serial.println(remotePort);
-  serializeJson(doc, Serial);
-
-  // Send UDP packet
-  udp.beginPacket(remoteIp, remotePort);
-  serializeJson(doc, udp);
-  udp.println();
-  udp.endPacket();
-
-  // Wait
-  delay(10000);
+  StaticJsonBuffer<300> jsonBuffer;
+  JsonObject& json = buildJson(jsonBuffer);
+  sendJson(json);
 }
-
-// Performance issue?
-// ------------------
-//
-// EthernetUDP is an unbuffered stream, which is not optimal for ArduinoJson.
-// See: https://arduinojson.org/v6/how-to/improve-speed/
-
-// 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
-// serialization problem.
-//
-// The book "Mastering ArduinoJson" contains a tutorial on serialization.
-// It begins with a simple example, then adds more features like serializing
-// directly to a file or any stream.
-// Learn more at https://arduinojson.org/book/
-// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/MsgPackParser/MsgPackParser.ino

@@ -1,75 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
-// MIT License
-//
-// This example shows how to deserialize a MessagePack document with
-// ArduinoJson.
-//
-// https://arduinojson.org/v6/example/msgpack-parser/
-
-#include <ArduinoJson.h>
-
-void setup() {
-  // Initialize serial port
-  Serial.begin(9600);
-  while (!Serial) continue;
-
-  // Allocate the JSON document
-  //
-  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
-  // Don't forget to change this value to match your JSON document.
-  // Use https://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);
-
-  // MessagePack input string.
-  //
-  // Using a char[], as shown here, enables the "zero-copy" mode. This mode uses
-  // the minimal amount of memory because the JsonDocument stores pointers to
-  // the input buffer.
-  // If you use another type of input, ArduinoJson must copy the strings from
-  // the input to the JsonDocument, so you need to increase the capacity of the
-  // JsonDocument.
-  uint8_t input[] = {131, 166, 115, 101, 110, 115, 111, 114, 163, 103, 112, 115,
-                     164, 116, 105, 109, 101, 206, 80,  147, 50,  248, 164, 100,
-                     97,  116, 97,  146, 203, 64,  72,  96,  199, 58,  188, 148,
-                     112, 203, 64,  2,   106, 146, 230, 33,  49,  169};
-  // This MessagePack document contains:
-  // {
-  //   "sensor": "gps",
-  //   "time": 1351824120,
-  //   "data": [48.75608, 2.302038]
-  // }
-
-  DeserializationError error = deserializeMsgPack(doc, input);
-
-  // Test if parsing succeeded.
-  if (error) {
-    Serial.print("deserializeMsgPack() failed: ");
-    Serial.println(error.f_str());
-    return;
-  }
-
-  // Fetch values.
-  //
-  // Most of the time, you can rely on the implicit casts.
-  // In other case, you can do doc["time"].as<long>();
-  const char* sensor = doc["sensor"];
-  long time = doc["time"];
-  double latitude = doc["data"][0];
-  double longitude = doc["data"][1];
-
-  // Print values.
-  Serial.println(sensor);
-  Serial.println(time);
-  Serial.println(latitude, 6);
-  Serial.println(longitude, 6);
-}
-
-void loop() {
-  // not used in this example
-}

examples/ProgmemExample/ProgmemExample.ino

@@ -1,64 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
-// MIT License
-//
-// This example shows the different ways you can use Flash strings with
-// ArduinoJson.
-//
-// Use Flash strings sparingly, because ArduinoJson duplicates them in the
-// JsonDocument. Prefer plain old char*, as they are more efficient in term of
-// code size, speed, and memory usage.
-//
-// https://arduinojson.org/v6/example/progmem/
-
-#include <ArduinoJson.h>
-
-void setup() {
-  DynamicJsonDocument 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
-  // No duplication is done.
-  long time = obj[F("time")];
-
-  // You can use a Flash String to set an element of a JsonObject
-  // WARNING: the content of the Flash String will be duplicated in the
-  // JsonDocument.
-  obj[F("time")] = time;
-
-  // You can set a Flash String to a JsonObject or JsonArray:
-  // WARNING: the content of the Flash String will be duplicated in the
-  // JsonDocument.
-  obj["sensor"] = F("gps");
-
-  // It works with serialized() too:
-  obj["sensor"] = serialized(F("\"gps\""));
-  obj["sensor"] = serialized(F("\xA3gps"), 3);
-
-  // You can compare the content of a JsonVariant to a Flash String
-  if (obj["sensor"] == F("gps")) {
-    // ...
-  }
-}
-
-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 memory
-// problem.
-//
-// The book "Mastering ArduinoJson" contains a quick C++ course that explains
-// how your microcontroller stores strings in memory. It also tells why you
-// should not abuse Flash strings with ArduinoJson.
-// Learn more at https://arduinojson.org/book/
-// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/StringExample/StringExample.ino

@@ -1,77 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
-// MIT License
-//
-// This example shows the different ways you can use String with ArduinoJson.
-//
-// Use String objects sparingly, because ArduinoJson duplicates them in the
-// JsonDocument. Prefer plain old char[], as they are more efficient in term of
-// code size, speed, and memory usage.
-//
-// https://arduinojson.org/v6/example/string/
-
-#include <ArduinoJson.h>
-
-void setup() {
-  DynamicJsonDocument 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
-  // No duplication is done.
-  long time = obj[String("time")];
-
-  // You can use a String to set an element of a JsonObject
-  // WARNING: the content of the String will be duplicated in the JsonDocument.
-  obj[String("time")] = time;
-
-  // You can get a String from a JsonObject or JsonArray:
-  // No duplication is done, at least not in the JsonDocument.
-  String sensor = obj["sensor"];
-
-  // Unfortunately, the following doesn't work (issue #118):
-  // sensor = obj["sensor"]; // <-  error "ambiguous overload for 'operator='"
-  // As a workaround, you need to replace by:
-  sensor = obj["sensor"].as<String>();
-
-  // You can set a String to a JsonObject or JsonArray:
-  // WARNING: the content of the String will be duplicated in the JsonDocument.
-  obj["sensor"] = sensor;
-
-  // It works with serialized() too:
-  obj["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";
-
-  // You can compare the content of a JsonObject with a String
-  if (obj["sensor"] == sensor) {
-    // ...
-  }
-
-  // Lastly, you can print the resulting JSON to a String
-  String output;
-  serializeJson(doc, output);
-}
-
-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 problem.
-//
-// The book "Mastering ArduinoJson" contains a quick C++ course that explains
-// how your microcontroller stores strings in memory. On several occasions, it
-// shows how you can avoid String in your program.
-// Learn more at https://arduinojson.org/book/
-// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

extras/ArduinoJsonConfig.cmake.in

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

extras/CompileOptions.cmake

@@ -1,94 +0,0 @@
-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(${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.
-	)
-
-	if (NOT MSVC_VERSION LESS  1910) #  >= Visual Studio 2017
-		add_compile_options(
-			/Zc:__cplusplus  # Enable updated __cplusplus macro
-		)
-	endif()
-endif()

extras/ci/espidf/CMakeLists.txt

@@ -1,8 +0,0 @@
-# ArduinoJson - https://arduinojson.org
-# Copyright © 2014-2022, 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

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

extras/ci/espidf/main/component.mk

@@ -1,4 +0,0 @@
-#
-# "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

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

extras/ci/particle.sh

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

extras/conf_test/avr.cpp

@@ -1,16 +0,0 @@
-#include <ArduinoJson.h>
-
-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_NAMESPACE::VariantSlot) == 8,
-              "sizeof(VariantSlot)");
-
-void setup() {}
-void loop() {}

extras/conf_test/esp8266.cpp

@@ -1,16 +0,0 @@
-#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_NAMESPACE::VariantSlot) == 16,
-              "sizeof(VariantSlot)");
-
-void setup() {}
-void loop() {}

extras/conf_test/x64.cpp

@@ -1,15 +0,0 @@
-#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_NAMESPACE::VariantSlot) == 32,
-              "sizeof(VariantSlot)");
-
-int main() {}

extras/conf_test/x86.cpp

@@ -1,15 +0,0 @@
-#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_NAMESPACE::VariantSlot) == 16,
-              "sizeof(VariantSlot)");
-
-int main() {}

extras/fuzzing/CMakeLists.txt

@@ -1,59 +0,0 @@
-# ArduinoJson - https://arduinojson.org
-# Copyright © 2014-2022, Benoit BLANCHON
-# MIT License
-
-if(MSVC)
-	add_compile_options(-D_CRT_SECURE_NO_WARNINGS)
-endif()
-
-add_executable(msgpack_reproducer
-	msgpack_fuzzer.cpp
-	reproducer.cpp
-)
-target_link_libraries(msgpack_reproducer
-	ArduinoJson
-)
-
-add_executable(json_reproducer
-	json_fuzzer.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,22 +0,0 @@
-# CAUTION: this file is invoked by https://github.com/google/oss-fuzz
-
-CXXFLAGS += -I../../src -DARDUINOJSON_DEBUG=1
-
-all: \
-	$(OUT)/json_fuzzer \
-	$(OUT)/json_fuzzer_seed_corpus.zip \
-	$(OUT)/json_fuzzer.options \
-	$(OUT)/msgpack_fuzzer \
-	$(OUT)/msgpack_fuzzer_seed_corpus.zip \
-	$(OUT)/msgpack_fuzzer.options
-
-$(OUT)/%_fuzzer: %_fuzzer.cpp $(shell find ../../src -type f)
-	$(CXX) $(CXXFLAGS) $< -o$@ $(LIB_FUZZING_ENGINE)
-
-$(OUT)/%_fuzzer_seed_corpus.zip: %_seed_corpus/*
-	zip -j $@ $?
-
-$(OUT)/%_fuzzer.options:
-	@echo "[libfuzzer]" > $@
-	@echo "max_len = 256" >> $@
-	@echo "timeout = 10" >> $@

extras/fuzzing/json_corpus/.gitignore

@@ -1,2 +0,0 @@
-*
-!.gitignore

extras/fuzzing/json_fuzzer.cpp

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

extras/fuzzing/json_seed_corpus/Comments.json

@@ -1,10 +0,0 @@
-//comment
-/*comment*/
-[ //comment
-/*comment*/"comment"/*comment*/,//comment
-/*comment*/{//comment
-/* comment*/"key"//comment
-: //comment
-"value"//comment
-}/*comment*/
-]//comment

extras/fuzzing/json_seed_corpus/EmptyArray.json

@@ -1 +0,0 @@
-[]

extras/fuzzing/json_seed_corpus/EmptyObject.json

@@ -1 +0,0 @@
-{}

extras/fuzzing/json_seed_corpus/ExcessiveNesting.json

@@ -1 +0,0 @@
-[1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,[14,[15,[16,[17,[18,[19,[20,[21,[22,[23,[24,[25,[26,[27,[28,[29,[30,[31,[32,[33,[34,[35,[36,[37,[38,[39,[40,[41,[42,[43,[44,[45,[46,[47,[48,[49,[50,[51,[52,[53,[54,[55,[56,[57,[58,[59,[60,[61,[62,[63,[64,[65,[66,[67,[68,[69,[70,[71,[72,[73,[74,[75,[76,[77,[78,[79,[80,[81,[82,[83,[84,[85,[86,[87,[88,[89,[90,[91,[92,[93,[94,[95,[96,[97,[98,[99,[100,[101,[102,[103,[104,[105,[106,[107,[108,[109,[110,[111,[112,[113,[114,[115,[116,[117,[118,[119,[120]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

extras/fuzzing/json_seed_corpus/IntegerOverflow.json

@@ -1 +0,0 @@
-9720730739393920739

extras/fuzzing/json_seed_corpus/Numbers.json

@@ -1,24 +0,0 @@
-[
-  123,
-  -123,
-  123.456,
-  -123.456,
-  12e34,
-  12e-34,
-  12e+34,
-  12E34,
-  12E-34,
-  12E+34,
-  12.34e56,
-  12.34e-56,
-  12.34e+56,
-  12.34E56,
-  12.34E-56,
-  12.34E+56,
-  NaN,
-  -NaN,
-  +NaN,
-  Infinity,
-  +Infinity,
-  -Infinity
-]

extras/fuzzing/json_seed_corpus/OpenWeatherMap.json

@@ -1,53 +0,0 @@
-{
-  "coord": {
-    "lon": -0.13,
-    "lat": 51.51
-  },
-  "weather": [
-    {
-      "id": 301,
-      "main": "Drizzle",
-      "description": "drizzle",
-      "icon": "09n"
-    },
-    {
-      "id": 701,
-      "main": "Mist",
-      "description": "mist",
-      "icon": "50n"
-    },
-    {
-      "id": 741,
-      "main": "Fog",
-      "description": "fog",
-      "icon": "50n"
-    }
-  ],
-  "base": "stations",
-  "main": {
-    "temp": 281.87,
-    "pressure": 1032,
-    "humidity": 100,
-    "temp_min": 281.15,
-    "temp_max": 283.15
-  },
-  "visibility": 2900,
-  "wind": {
-    "speed": 1.5
-  },
-  "clouds": {
-    "all": 90
-  },
-  "dt": 1483820400,
-  "sys": {
-    "type": 1,
-    "id": 5091,
-    "message": 0.0226,
-    "country": "GB",
-    "sunrise": 1483776245,
-    "sunset": 1483805443
-  },
-  "id": 2643743,
-  "name": "London",
-  "cod": 200
-}

extras/fuzzing/json_seed_corpus/Strings.json

@@ -1,8 +0,0 @@
-[
-  "hello",
-  'hello',
-  hello,
-  {"hello":"world"},
-  {'hello':'world'},
-  {hello:world}
-]

extras/fuzzing/json_seed_corpus/WeatherUnderground.json

@@ -1,90 +0,0 @@
-{
-  "response": {
-    "version": "0.1",
-    "termsofService": "http://www.wunderground.com/weather/api/d/terms.html",
-    "features": {
-      "conditions": 1
-    }
-  },
-  "current_observation": {
-    "image": {
-      "url": "http://icons-ak.wxug.com/graphics/wu2/logo_130x80.png",
-      "title": "Weather Underground",
-      "link": "http://www.wunderground.com"
-    },
-    "display_location": {
-      "full": "San Francisco, CA",
-      "city": "San Francisco",
-      "state": "CA",
-      "state_name": "California",
-      "country": "US",
-      "country_iso3166": "US",
-      "zip": "94101",
-      "latitude": "37.77500916",
-      "longitude": "-122.41825867",
-      "elevation": "47.00000000"
-    },
-    "observation_location": {
-      "full": "SOMA - Near Van Ness, San Francisco, California",
-      "city": "SOMA - Near Van Ness, San Francisco",
-      "state": "California",
-      "country": "US",
-      "country_iso3166": "US",
-      "latitude": "37.773285",
-      "longitude": "-122.417725",
-      "elevation": "49 ft"
-    },
-    "estimated": {},
-    "station_id": "KCASANFR58",
-    "observation_time": "Last Updated on June 27, 5:27 PM PDT",
-    "observation_time_rfc822": "Wed, 27 Jun 2012 17:27:13 -0700",
-    "observation_epoch": "1340843233",
-    "local_time_rfc822": "Wed, 27 Jun 2012 17:27:14 -0700",
-    "local_epoch": "1340843234",
-    "local_tz_short": "PDT",
-    "local_tz_long": "America/Los_Angeles",
-    "local_tz_offset": "-0700",
-    "weather": "Partly Cloudy",
-    "temperature_string": "66.3 F (19.1 C)",
-    "temp_f": 66.3,
-    "temp_c": 19.1,
-    "relative_humidity": "65%",
-    "wind_string": "From the NNW at 22.0 MPH Gusting to 28.0 MPH",
-    "wind_dir": "NNW",
-    "wind_degrees": 346,
-    "wind_mph": 22,
-    "wind_gust_mph": "28.0",
-    "wind_kph": 35.4,
-    "wind_gust_kph": "45.1",
-    "pressure_mb": "1013",
-    "pressure_in": "29.93",
-    "pressure_trend": "+",
-    "dewpoint_string": "54 F (12 C)",
-    "dewpoint_f": 54,
-    "dewpoint_c": 12,
-    "heat_index_string": "NA",
-    "heat_index_f": "NA",
-    "heat_index_c": "NA",
-    "windchill_string": "NA",
-    "windchill_f": "NA",
-    "windchill_c": "NA",
-    "feelslike_string": "66.3 F (19.1 C)",
-    "feelslike_f": "66.3",
-    "feelslike_c": "19.1",
-    "visibility_mi": "10.0",
-    "visibility_km": "16.1",
-    "solarradiation": "",
-    "UV": "5",
-    "precip_1hr_string": "0.00 in ( 0 mm)",
-    "precip_1hr_in": "0.00",
-    "precip_1hr_metric": " 0",
-    "precip_today_string": "0.00 in (0 mm)",
-    "precip_today_in": "0.00",
-    "precip_today_metric": "0",
-    "icon": "partlycloudy",
-    "icon_url": "http://icons-ak.wxug.com/i/c/k/partlycloudy.gif",
-    "forecast_url": "http://www.wunderground.com/US/CA/San_Francisco.html",
-    "history_url": "http://www.wunderground.com/history/airport/KCASANFR58/2012/6/27/DailyHistory.html",
-    "ob_url": "http://www.wunderground.com/cgi-bin/findweather/getForecast?query=37.773285,-122.417725"
-  }
-}

extras/fuzzing/msgpack_corpus/.gitignore

@@ -1,2 +0,0 @@
-*
-!.gitignore

extras/fuzzing/msgpack_fuzzer.cpp

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

extras/fuzzing/msgpack_seed_corpus/false

@@ -1 +0,0 @@
-<EFBFBD>

extras/fuzzing/msgpack_seed_corpus/fixarray

@@ -1 +0,0 @@
-<EFBFBD><EFBFBD>hello<EFBFBD>world

extras/fuzzing/msgpack_seed_corpus/fixint_negative

@@ -1 +0,0 @@
-<EFBFBD>

extras/fuzzing/msgpack_seed_corpus/fixint_positive

@@ -1 +0,0 @@
-

extras/fuzzing/msgpack_seed_corpus/fixmap

@@ -1 +0,0 @@
-<EFBFBD><EFBFBD>one
<01>two

extras/fuzzing/msgpack_seed_corpus/fixstr

@@ -1 +0,0 @@
-<EFBFBD>hello world

extras/fuzzing/msgpack_seed_corpus/float32

@@ -1 +0,0 @@
-<EFBFBD>@H<><48>

extras/fuzzing/msgpack_seed_corpus/float64

@@ -1 +0,0 @@
-<EFBFBD>@	!<21><><EFBFBD>o

extras/fuzzing/msgpack_seed_corpus/int16

@@ -1 +0,0 @@
-<EFBFBD><EFBFBD><EFBFBD>

extras/fuzzing/msgpack_seed_corpus/int32

@@ -1 +0,0 @@
-Ҷi<EFBFBD>.

extras/fuzzing/msgpack_seed_corpus/int64

@@ -1 +0,0 @@
-<EFBFBD>4Vx<56><78><EFBFBD><EFBFBD>

extras/fuzzing/msgpack_seed_corpus/int8

@@ -1 +0,0 @@
-<EFBFBD><EFBFBD>

extras/fuzzing/msgpack_seed_corpus/nil

@@ -1 +0,0 @@
-<EFBFBD>

extras/fuzzing/msgpack_seed_corpus/str8

@@ -1 +0,0 @@
-<EFBFBD>hello

extras/fuzzing/msgpack_seed_corpus/true

@@ -1 +0,0 @@
-<EFBFBD>

extras/fuzzing/msgpack_seed_corpus/uint16

@@ -1 +0,0 @@
-<EFBFBD>09

extras/fuzzing/msgpack_seed_corpus/uint32

@@ -1 +0,0 @@
-<EFBFBD>4Vx

extras/fuzzing/msgpack_seed_corpus/uint64

@@ -1 +0,0 @@
-<EFBFBD>4Vx<56><78><EFBFBD><EFBFBD>

extras/fuzzing/msgpack_seed_corpus/uint8

@@ -1 +0,0 @@
-<EFBFBD><EFBFBD>

extras/fuzzing/reproducer.cpp

@@ -1,50 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
-// MIT License
-
-// This file is NOT use by Google's OSS fuzz
-// I only use it to reproduce the bugs found
-
-#include <stdint.h>  // size_t
-#include <stdio.h>   // fopen et al.
-#include <stdlib.h>  // exit
-#include <iostream>
-#include <vector>
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
-
-std::vector<uint8_t> read(const char* path) {
-  FILE* f = fopen(path, "rb");
-  if (!f) {
-    std::cerr << "Failed to open " << path << std::endl;
-    exit(1);
-  }
-
-  fseek(f, 0, SEEK_END);
-  size_t size = static_cast<size_t>(ftell(f));
-  fseek(f, 0, SEEK_SET);
-
-  std::vector<uint8_t> buffer(size);
-  if (fread(buffer.data(), 1, size, f) != size) {
-    fclose(f);
-    std::cerr << "Failed to read " << path << std::endl;
-    exit(1);
-  }
-
-  fclose(f);
-  return buffer;
-}
-
-int main(int argc, const char* argv[]) {
-  if (argc < 2) {
-    std::cerr << "Usage: msgpack_fuzzer files" << std::endl;
-    return 1;
-  }
-
-  for (int i = 1; i < argc; i++) {
-    std::cout << "Loading " << argv[i] << std::endl;
-    std::vector<uint8_t> buffer = read(argv[i]);
-    LLVMFuzzerTestOneInput(buffer.data(), buffer.size());
-  }
-  return 0;
-}

extras/particle/project.properties

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

extras/particle/src/smocktest.ino

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

extras/scripts/build-arduino-package.sh

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

extras/scripts/build-single-header.sh

@@ -1,64 +0,0 @@
-#!/bin/bash
-
-set -e
-
-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")"
-
-
-declare -A INCLUDED
-
-process()
-{
-	local PARENT=$1
-	local FOLDER=$(dirname $1)
-	local SHOW_COMMENT=$2
-	while IFS= read -r LINE; do
-		if [[ $LINE =~ $RE_ABSOLUTE_INCLUDE ]]; then
-			local CHILD=${BASH_REMATCH[1]}
-			local CHILD_PATH
-			CHILD_PATH=$(realpath "$SRC_DIRECTORY/$CHILD")
-			echo "$PARENT -> $CHILD" >&2
-			if [[ ! ${INCLUDED[$CHILD_PATH]} ]]; then
-				INCLUDED[$CHILD_PATH]=true
-				process "$CHILD" false
-			fi
-		elif [[ $LINE =~ $RE_RELATIVE_INCLUDE ]]; then
-			local CHILD=${BASH_REMATCH[1]}
-			pushd "$FOLDER" > /dev/null
-			local CHILD_PATH
-			CHILD_PATH=$(realpath "$CHILD")
-			echo "$PARENT -> $CHILD" >&2
-			if [[ ! ${INCLUDED[$CHILD_PATH]} ]]; then
-				INCLUDED[$CHILD_PATH]=true
-				process "$CHILD" false
-			fi
-			popd > /dev/null
-		elif [[ $LINE =~ $RE_SYSTEM_INCLUDE ]]; then
-			local CHILD=${BASH_REMATCH[1]}
-			echo "$PARENT -> <$CHILD>" >&2
-			if [[ ! ${INCLUDED[$CHILD]} ]]; then
-				echo "#include <$CHILD>"
-				INCLUDED[$CHILD]=true
-			fi
-		elif [[ "${SHOW_COMMENT}" = "true" ]] ; then
-			echo "$LINE"
-		elif [[ ! $LINE =~ $RE_EMPTY ]]; then
-			echo "$LINE"
-		fi
-	done < $PARENT
-}
-
-simplify_namespaces() {
-	perl -p0i -e 's|\}  // namespace ARDUINOJSON_NAMESPACE\r?\nnamespace ARDUINOJSON_NAMESPACE \{\r?\n||igs' "$1"
-	rm -f "$1.bak"
-}
-
-INCLUDED=()
-INPUT=$1
-OUTPUT=$2
-process "$INPUT" true > "$OUTPUT"
-simplify_namespaces "$OUTPUT"

extras/scripts/get-release-body.sh

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

extras/scripts/get-release-page.sh

@@ -1,18 +0,0 @@
-#!/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

@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu
-
-SOURCE_DIR="$(dirname "$0")/../.."
-WORK_DIR=$(mktemp -d)
-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 -r "$SOURCE_DIR/src" "$WORK_DIR/"
-cp -r "$SOURCE_DIR/examples" "$WORK_DIR/"
-
-cd "$WORK_DIR"
-particle library upload
-particle library publish

extras/scripts/publish.sh

@@ -1,73 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu
-
-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-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 "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~
-
-	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~
-
-	sed -i~ -bE "s/version=.*$/version=$VERSION/" library.properties
-	rm library.properties~
-
-	sed -i~ -bE "s/version: .*$/version: $VERSION.{build}/" appveyor.yml
-	rm appveyor.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/" \
-		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 CMakeLists.txt
-	git commit -m "Set version to $VERSION"
-}
-
-add_tag () {
-	CHANGES=$(awk '/\* /{ FOUND=1; print; next } { if (FOUND) exit}' CHANGELOG.md)
-	git tag -m "ArduinoJson $VERSION"$'\n'"$CHANGES" "$TAG"
-}
-
-push () {
-	git push --follow-tags
-}
-
-update_version_in_source
-commit_new_version
-add_tag
-push
-
-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"
-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,60 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
-// MIT License
-//
-// This example shows how to generate a JSON document with ArduinoJson.
-
-#include <iostream>
-#include "ArduinoJson.h"
-
-int main() {
-  // Allocate the JSON document
-  //
-  // Inside the brackets, 200 is the RAM allocated to this document.
-  // Don't forget to change this value to match your requirement.
-  // Use https://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);
-
-  // Add values in the document
-  //
-  doc["sensor"] = "gps";
-  doc["time"] = 1351824120;
-
-  // Add an array.
-  //
-  JsonArray data = doc.createNestedArray("data");
-  data.add(48.756080);
-  data.add(2.302038);
-
-  // Generate the minified JSON and send it to STDOUT
-  //
-  serializeJson(doc, std::cout);
-  // The above line prints:
-  // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
-
-  // Start a new line
-  std::cout << std::endl;
-
-  // Generate the prettified JSON and send it to STDOUT
-  //
-  serializeJsonPretty(doc, std::cout);
-  // The above line prints:
-  // {
-  //   "sensor": "gps",
-  //   "time": 1351824120,
-  //   "data": [
-  //     48.756080,
-  //     2.302038
-  //   ]
-  // }
-}

extras/scripts/wandbox/JsonParserExample.cpp

@@ -1,59 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
-// MIT License
-//
-// This example shows how to deserialize a JSON document with ArduinoJson.
-
-#include <iostream>
-#include "ArduinoJson.h"
-
-int main() {
-  // Allocate the JSON document
-  //
-  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
-  // Don't forget to change this value to match your JSON document.
-  // Use https://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);
-
-  // JSON input string.
-  //
-  // Using a char[], as shown here, enables the "zero-copy" mode. This mode uses
-  // the minimal amount of memory because the JsonDocument stores pointers to
-  // the input buffer.
-  // If you use another type of input, ArduinoJson must copy the strings from
-  // the input to the JsonDocument, so you need to increase the capacity of the
-  // JsonDocument.
-  char json[] =
-      "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
-
-  // Deserialize the JSON document
-  DeserializationError error = deserializeJson(doc, json);
-
-  // Test if parsing succeeds.
-  if (error) {
-    std::cerr << "deserializeJson() failed: " << error.c_str() << std::endl;
-    return 1;
-  }
-
-  // Fetch values.
-  //
-  // Most of the time, you can rely on the implicit casts.
-  // In other case, you can do doc["time"].as<long>();
-  const char* sensor = doc["sensor"];
-  long time = doc["time"];
-  double latitude = doc["data"][0];
-  double longitude = doc["data"][1];
-
-  // Print values.
-  std::cout << sensor << std::endl;
-  std::cout << time << std::endl;
-  std::cout << latitude << std::endl;
-  std::cout << longitude << std::endl;
-
-  return 0;
-}

extras/scripts/wandbox/MsgPackParserExample.cpp

@@ -1,68 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2022, Benoit BLANCHON
-// MIT License
-//
-// This example shows how to generate a JSON document with ArduinoJson.
-
-#include <iostream>
-#include "ArduinoJson.h"
-
-int main() {
-  // Allocate the JSON document
-  //
-  // Inside the brackets, 300 is the size of the memory pool in bytes.
-  // Don't forget to change this value to match your JSON document.
-  // Use https://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);
-
-  // MessagePack input string.
-  //
-  // It's better to use a char[] as shown here.
-  // If you use a const char* or a String, ArduinoJson will
-  // have to make a copy of the input in the JsonBuffer.
-  uint8_t input[] = {131, 166, 115, 101, 110, 115, 111, 114, 163, 103, 112, 115,
-                     164, 116, 105, 109, 101, 206, 80,  147, 50,  248, 164, 100,
-                     97,  116, 97,  146, 203, 64,  72,  96,  199, 58,  188, 148,
-                     112, 203, 64,  2,   106, 146, 230, 33,  49,  169};
-  // This MessagePack document contains:
-  // {
-  //   "sensor": "gps",
-  //   "time": 1351824120,
-  //   "data": [48.75608, 2.302038]
-  // }
-
-  // doc of the object tree.
-  //
-  // It's a reference to the JsonObject, the actual bytes are inside the
-  // JsonBuffer with all the other nodes of the object tree.
-  // Memory is freed when jsonBuffer goes out of scope.
-  DeserializationError error = deserializeMsgPack(doc, input);
-
-  // Test if parsing succeeds.
-  if (error) {
-    std::cerr << "deserializeMsgPack() failed: " << error.c_str() << std::endl;
-    return 1;
-  }
-
-  // Fetch values.
-  //
-  // Most of the time, you can rely on the implicit casts.
-  // In other case, you can do doc["time"].as<long>();
-  const char* sensor = doc["sensor"];
-  long time = doc["time"];
-  double latitude = doc["data"][0];
-  double longitude = doc["data"][1];
-
-  // Print values.
-  std::cout << sensor << std::endl;
-  std::cout << time << std::endl;
-  std::cout << latitude << std::endl;
-  std::cout << longitude << std::endl;
-
-  return 0;
-}

extras/scripts/wandbox/publish.sh

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu
-
-ARDUINOJSON_H="$1"
-
-read_string() {
-	jq --slurp --raw-input '.' "$1"
-}
-
-compile() {
-	FILE_PATH="$(dirname $0)/$1.cpp"
-	cat >parameters.json <<END
-{
-  "code":$(read_string "$FILE_PATH"),
-  "codes": [{"file":"ArduinoJson.h","code":$(read_string "$ARDUINOJSON_H")}],
-  "options": "warning",
-  "compiler": "gcc-4.9.3",
-  "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"
-}
-
-compile "JsonGeneratorExample"
-compile "JsonParserExample"
-compile "MsgPackParserExample"

extras/tests/.clang-tidy

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