andry/EMS-ESP32
1
0
Fork 0
mirror of https://github.com/emsesp/EMS-ESP32.git synced 2026-01-30 02:29:12 +03:00
Code Issues Packages Projects Releases Wiki Activity

local libs

Browse Source
This commit is contained in:
proddy
2020-10-06 20:54:02 +02:00
parent 13297334cf
commit 50da856c45
451 changed files with 20629 additions and 37550 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
lib_standalone/ArduinoJson/ArduinoJson.h → lib/ArduinoJson/ArduinoJson.h
View File

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

1963
lib_standalone/ArduinoJson/CHANGELOG.md → lib/ArduinoJson/CHANGELOG.md
View File

File diff suppressed because it is too large Load Diff

20
lib_standalone/ArduinoJson/LICENSE.md → lib/ArduinoJson/LICENSE.md
View File

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

274
lib_standalone/ArduinoJson/README.md → lib/ArduinoJson/README.md
View File

@@ -1,137 +1,137 @@
![ArduinoJson](banner.svg) ![ArduinoJson](banner.svg)
--- ---
[![arduino-library-badge](https://www.ardu-badge.com/badge/ArduinoJson.svg?version=6.15.0)](https://www.ardu-badge.com/ArduinoJson/6.15.0) [![arduino-library-badge](https://www.ardu-badge.com/badge/ArduinoJson.svg?version=6.16.1)](https://www.ardu-badge.com/ArduinoJson/6.16.1)
[![Build Status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/6.x?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/6.x) [![Build Status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/6.x?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/6.x)
[![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=6.x)](https://travis-ci.org/bblanchon/ArduinoJson) [![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=6.x)](https://travis-ci.org/bblanchon/ArduinoJson)
[![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) [![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/arduinojson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:arduinojson)
[![Coverage Status](https://coveralls.io/repos/github/bblanchon/ArduinoJson/badge.svg?branch=6.x)](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x) [![Coverage Status](https://coveralls.io/repos/github/bblanchon/ArduinoJson/badge.svg?branch=6.x)](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x)
[![GitHub stars](https://img.shields.io/github/stars/bblanchon/ArduinoJson?style=flat)](https://github.com/bblanchon/ArduinoJson/stargazers) [![GitHub stars](https://img.shields.io/github/stars/bblanchon/ArduinoJson?style=flat)](https://github.com/bblanchon/ArduinoJson/stargazers)
ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things). ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).
## Features ## Features
* [JSON deserialization](https://arduinojson.org/v6/api/json/deserializejson/?utm_source=github&utm_medium=readme) * [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 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 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 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/#filtering?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 * Supports single quotes as a string delimiter
* Compatible with NDJSON and JSON Lines * Compatible with NDJSON and JSON Lines
* [JSON serialization](https://arduinojson.org/v6/api/json/serializejson/?utm_source=github&utm_medium=readme) * [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) * [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) * [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 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) * [MessagePack deserialization](https://arduinojson.org/v6/api/msgpack/deserializemsgpack/?utm_source=github&utm_medium=readme)
* Efficient * 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) * [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) * [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) * [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) * [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) * [Optionally works without heap memory (zero malloc)](https://arduinojson.org/v6/api/staticjsondocument/?utm_source=github&utm_medium=readme)
* Versatile * Deduplicates strings
* [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) * Versatile
* Supports [Arduino's `String`](https://arduinojson.org/v6/api/config/enable_arduino_string/) and [STL's `std::string`](https://arduinojson.org/v6/api/config/enable_std_string/?utm_source=github&utm_medium=readme) * [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 Arduino's `Stream` and [STL's `std::istream`/`std::ostream`](https://arduinojson.org/v6/api/config/enable_std_stream/?utm_source=github&utm_medium=readme) * Supports [Arduino's `String`](https://arduinojson.org/v6/api/config/enable_arduino_string/) and [STL's `std::string`](https://arduinojson.org/v6/api/config/enable_std_string/?utm_source=github&utm_medium=readme)
* [Supports Flash strings](https://arduinojson.org/v6/api/config/enable_progmem/?utm_source=github&utm_medium=readme) * Supports Arduino's `Stream` and [STL's `std::istream`/`std::ostream`](https://arduinojson.org/v6/api/config/enable_std_stream/?utm_source=github&utm_medium=readme)
* Supports [custom readers](https://arduinojson.org/v6/api/json/deserializejson/#custom-reader) and [custom writers](https://arduinojson.org/v6/api/json/serializejson/#custom-writer?utm_source=github&utm_medium=readme) * [Supports Flash strings](https://arduinojson.org/v6/api/config/enable_progmem/?utm_source=github&utm_medium=readme)
* Portable * 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)
* Usable on any C++ project (not limited to Arduino) * Portable
* Compatible with C++98 * Usable on any C++ project (not limited to Arduino)
* Zero warnings with `-Wall -Wextra -pedantic` and `/W4` * Compatible with C++98
* [Header-only library](https://en.wikipedia.org/wiki/Header-only) * Zero warnings with `-Wall -Wextra -pedantic` and `/W4`
* Works with virtually any board * [Header-only library](https://en.wikipedia.org/wiki/Header-only)
* 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)... * Works with virtually any board
* Espressif chips: [ESP8266](https://amzn.to/36YluV8), [ESP32](https://amzn.to/2G4pRCB) * 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)...
* Lolin (WeMos) boards: [D1 mini](https://amzn.to/2QUpz7q), [D1 Mini Pro](https://amzn.to/36UsGSs)... * Espressif chips: [ESP8266](https://amzn.to/36YluV8), [ESP32](https://amzn.to/2G4pRCB)
* Teensy boards: [4.0](https://amzn.to/30ljXGq), [3.2](https://amzn.to/2FT0EuC), [2.0](https://amzn.to/2QXUMXj) * Lolin (WeMos) boards: [D1 mini](https://amzn.to/2QUpz7q), [D1 Mini Pro](https://amzn.to/36UsGSs)...
* Particle boards: [Argon](https://amzn.to/2FQHa9X), [Boron](https://amzn.to/36WgLUd), [Electron](https://amzn.to/30vEc4k), [Photon](https://amzn.to/387F9Cd)... * Teensy boards: [4.0](https://amzn.to/30ljXGq), [3.2](https://amzn.to/2FT0EuC), [2.0](https://amzn.to/2QXUMXj)
* Texas Instruments boards: [MSP430](https://amzn.to/30nJWgg)... * Particle boards: [Argon](https://amzn.to/2FQHa9X), [Boron](https://amzn.to/36WgLUd), [Electron](https://amzn.to/30vEc4k), [Photon](https://amzn.to/387F9Cd)...
* Tested on all major development environments * Texas Instruments boards: [MSP430](https://amzn.to/30nJWgg)...
* [Arduino IDE](https://www.arduino.cc/en/Main/Software) * Tested on all major development environments
* [Atmel Studio](http://www.atmel.com/microsite/atmel-studio/) * [Arduino IDE](https://www.arduino.cc/en/Main/Software)
* [Atollic TrueSTUDIO](https://atollic.com/truestudio/) * [Atmel Studio](http://www.atmel.com/microsite/atmel-studio/)
* [Energia](http://energia.nu/) * [Atollic TrueSTUDIO](https://atollic.com/truestudio/)
* [IAR Embedded Workbench](https://www.iar.com/iar-embedded-workbench/) * [Energia](http://energia.nu/)
* [Keil uVision](http://www.keil.com/) * [IAR Embedded Workbench](https://www.iar.com/iar-embedded-workbench/)
* [MPLAB X IDE](http://www.microchip.com/mplab/mplab-x-ide) * [Keil uVision](http://www.keil.com/)
* [PlatformIO](http://platformio.org/) * [MPLAB X IDE](http://www.microchip.com/mplab/mplab-x-ide)
* [Sloeber plugin for Eclipse](https://eclipse.baeyens.it/) * [PlatformIO](http://platformio.org/)
* [Visual Micro](http://www.visualmicro.com/) * [Sloeber plugin for Eclipse](https://eclipse.baeyens.it/)
* [Visual Studio](https://www.visualstudio.com/) * [Visual Micro](http://www.visualmicro.com/)
* [Even works with online compilers like wandbox.org](https://wandbox.org/permlink/t7KP7I6dVuLhqzDl) * [Visual Studio](https://www.visualstudio.com/)
* Well designed * [Even works with online compilers like wandbox.org](https://wandbox.org/permlink/t7KP7I6dVuLhqzDl)
* [Elegant API](http://127.0.0.1:4000/v6/example/) * [CMake friendly](https://arduinojson.org/v6/how-to/use-arduinojson-with-cmake/?utm_source=github&utm_medium=readme)
* [Thread-safe](https://en.wikipedia.org/wiki/Thread_safety) * Well designed
* Self-contained (no external dependency) * [Elegant API](http://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme)
* `const` friendly * [Thread-safe](https://en.wikipedia.org/wiki/Thread_safety)
* [`for` friendly](https://arduinojson.org/v6/api/jsonobject/begin_end/?utm_source=github&utm_medium=readme) * Self-contained (no external dependency)
* [TMP friendly](https://en.wikipedia.org/wiki/Template_metaprogramming) * `const` friendly
* Handles [integer overflows](https://arduinojson.org/v6/api/jsonvariant/as/#integer-overflows?utm_source=github&utm_medium=readme) * [`for` friendly](https://arduinojson.org/v6/api/jsonobject/begin_end/?utm_source=github&utm_medium=readme)
* Well tested * [TMP friendly](https://en.wikipedia.org/wiki/Template_metaprogramming)
* [Unit test coverage close to 100%](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x) * Handles [integer overflows](https://arduinojson.org/v6/api/jsonvariant/as/?utm_source=github&utm_medium=readme#integer-overflows)
* Continuously tested on * Well tested
* [Visual Studio 2010, 2012, 2013, 2015, 2017, 2019](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/6.x) * [Unit test coverage close to 100%](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x)
* [GCC 4.4, 4.6, 4.7, 4.8, 4.9, 5, 6, 7, 8](https://travis-ci.org/bblanchon/ArduinoJson) * Continuously tested on
* [Clang 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 5.0, 6.0, 7, 8](https://travis-ci.org/bblanchon/ArduinoJson) * [Visual Studio 2010, 2012, 2013, 2015, 2017, 2019](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/6.x)
* [Continuously fuzzed with Google OSS Fuzz](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:arduinojson) * [GCC 4.4, 4.6, 4.7, 4.8, 4.9, 5, 6, 7, 8](https://travis-ci.org/bblanchon/ArduinoJson)
* Well documented * [Clang 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 5.0, 6.0, 7, 8](https://travis-ci.org/bblanchon/ArduinoJson)
* [Tutorials](https://arduinojson.org/v6/doc/deserialization/?utm_source=github&utm_medium=readme) * [Continuously fuzzed with Google OSS Fuzz](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:arduinojson)
* [Examples](https://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme) * Well documented
* [How-tos](https://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme) * [Tutorials](https://arduinojson.org/v6/doc/deserialization/?utm_source=github&utm_medium=readme)
* [FAQ](https://arduinojson.org/v6/faq/?utm_source=github&utm_medium=readme) * [Examples](https://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme)
* [Book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme) * [How-tos](https://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme)
* Vibrant user community * [FAQ](https://arduinojson.org/v6/faq/?utm_source=github&utm_medium=readme)
* Most popular of all Arduino libraries on [GitHub](https://github.com/search?o=desc&q=arduino+library&s=stars&type=Repositories) and [PlatformIO](https://platformio.org/lib/search) * [Book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme)
* [Used in hundreds of projects](https://www.hackster.io/search?i=projects&q=arduinojson) * Vibrant user community
* [Responsive support](https://github.com/bblanchon/ArduinoJson/issues?q=is%3Aissue+is%3Aclosed) * Most popular of all Arduino libraries on [GitHub](https://github.com/search?o=desc&q=arduino+library&s=stars&type=Repositories) and [PlatformIO](https://platformio.org/lib/search)
* [Used in hundreds of projects](https://www.hackster.io/search?i=projects&q=arduinojson)
## Quickstart * [Responsive support](https://github.com/bblanchon/ArduinoJson/issues?q=is%3Aissue+is%3Aclosed)
### Deserialization ## Quickstart
Here is a program that parses a JSON document with ArduinoJson. ### Deserialization
```c++ Here is a program that parses a JSON document with ArduinoJson.
char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
```c++
DynamicJsonDocument doc(1024); char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
deserializeJson(doc, json);
DynamicJsonDocument doc(1024);
const char* sensor = doc["sensor"]; deserializeJson(doc, json);
long time = doc["time"];
double latitude = doc["data"][0]; const char* sensor = doc["sensor"];
double longitude = doc["data"][1]; long time = doc["time"];
``` double latitude = doc["data"][0];
double longitude = doc["data"][1];
See the [tutorial on arduinojson.org](https://arduinojson.org/doc/decoding/?utm_source=github&utm_medium=readme) ```
### Serialization See the [tutorial on arduinojson.org](https://arduinojson.org/doc/decoding/?utm_source=github&utm_medium=readme)
Here is a program that generates a JSON document with ArduinoJson: ### Serialization
```c++ Here is a program that generates a JSON document with ArduinoJson:
DynamicJsonDocument doc(1024);
```c++
doc["sensor"] = "gps"; DynamicJsonDocument doc(1024);
doc["time"] = 1351824120;
doc["sensor"] = "gps";
JsonArray data = doc.createNestedArray("data"); doc["time"] = 1351824120;
data.add(48.756080); doc["data"][0] = 48.756080;
data.add(2.302038); doc["data"][1] = 2.302038;
serializeJson(doc, Serial); serializeJson(doc, Serial);
// This prints: // This prints:
// {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]} // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
``` ```
See the [tutorial on arduinojson.org](https://arduinojson.org/doc/encoding/?utm_source=github&utm_medium=readme) See the [tutorial on arduinojson.org](https://arduinojson.org/doc/encoding/?utm_source=github&utm_medium=readme)
## Support the project ## Support the project
Do you like this library? Please [star this project on GitHub](https://github.com/bblanchon/ArduinoJson/stargazers)! Do you like this library? Please [star this project on GitHub](https://github.com/bblanchon/ArduinoJson/stargazers)!
What? You don't like it but you *love* it? What? You don't like it but you *love* it?
We don't take donations anymore, but [we sell a book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme), so you can help and learn at the same time?utm_source=github&utm_medium=readme! We don't take donations anymore, but [we sell a book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme), so you can help and learn at the same time.

154
lib/ArduinoJson/examples/JsonConfigFile/JsonConfigFile.ino Normal file
View File

@@ -0,0 +1,154 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020
// 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 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 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
}
// 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 ❤❤❤❤❤

63
lib/ArduinoJson/examples/JsonFilterExample/JsonFilterExample.ino Normal file
View File

@@ -0,0 +1,63 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020
// 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 ❤❤❤❤❤

137
lib_standalone/ArduinoJson/extras/scripts/wandbox/JsonGeneratorExample.cpp → lib/ArduinoJson/examples/JsonGeneratorExample/JsonGeneratorExample.ino
View File

@@ -1,60 +1,77 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
// //
// This example shows how to generate a JSON document with ArduinoJson. // This example shows how to generate a JSON document with ArduinoJson.
//
#include <iostream> // https://arduinojson.org/v6/example/generator/
#include "ArduinoJson.h"
#include <ArduinoJson.h>
int main() {
// Allocate the JSON document void setup() {
// // Initialize Serial port
// Inside the brackets, 200 is the RAM allocated to this document. Serial.begin(9600);
// Don't forget to change this value to match your requirement. while (!Serial) continue;
// Use arduinojson.org/v6/assistant to compute the capacity.
StaticJsonDocument<200> doc; // Allocate the JSON document
//
// StaticJsonObject allocates memory on the stack, it can be // Inside the brackets, 200 is the RAM allocated to this document.
// replaced by DynamicJsonDocument which allocates in the heap. // Don't forget to change this value to match your requirement.
// // Use arduinojson.org/v6/assistant to compute the capacity.
// DynamicJsonDocument doc(200); StaticJsonDocument<200> doc;
// StaticJsonObject allocates memory on the stack, it can be // StaticJsonObject allocates memory on the stack, it can be
// replaced by DynamicJsonDocument which allocates in the heap. // replaced by DynamicJsonDocument which allocates in the heap.
// //
// DynamicJsonDocument doc(200); // DynamicJsonDocument doc(200);
// Add values in the document // Add values in the document
// //
doc["sensor"] = "gps"; doc["sensor"] = "gps";
doc["time"] = 1351824120; doc["time"] = 1351824120;
// Add an array. // Add an array.
// //
JsonArray data = doc.createNestedArray("data"); JsonArray data = doc.createNestedArray("data");
data.add(48.756080); data.add(48.756080);
data.add(2.302038); data.add(2.302038);
// Generate the minified JSON and send it to STDOUT // Generate the minified JSON and send it to the Serial port.
// //
serializeJson(doc, std::cout); serializeJson(doc, Serial);
// The above line prints: // The above line prints:
// {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]} // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
// Start a new line // Start a new line
std::cout << std::endl; Serial.println();
// Generate the prettified JSON and send it to STDOUT // Generate the prettified JSON and send it to the Serial port.
// //
serializeJsonPretty(doc, std::cout); serializeJsonPretty(doc, Serial);
// The above line prints: // The above line prints:
// { // {
// "sensor": "gps", // "sensor": "gps",
// "time": 1351824120, // "time": 1351824120,
// "data": [ // "data": [
// 48.756080, // 48.756080,
// 2.302038 // 2.302038
// ] // ]
// } // }
} }
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 ❤❤❤❤❤

116
lib/ArduinoJson/examples/JsonHttpClient/JsonHttpClient.ino Normal file
View File

@@ -0,0 +1,116 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020
// MIT License
//
// This example shows how to parse a JSON document in an HTTP response.
// It uses the Ethernet library, but can be easily adapted for Wifi.
//
// It performs a GET resquest on arduinojson.org/example.json
// 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"));
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);
return;
}
// Skip HTTP headers
char endOfHeaders[] = "\r\n\r\n";
if (!client.find(endOfHeaders)) {
Serial.println(F("Invalid response"));
return;
}
// Allocate the JSON document
// Use arduinojson.org/v6/assistant to compute the capacity.
const size_t capacity = JSON_OBJECT_SIZE(3) + JSON_ARRAY_SIZE(2) + 60;
DynamicJsonDocument doc(capacity);
// Parse JSON object
DeserializationError error = deserializeJson(doc, client);
if (error) {
Serial.print(F("deserializeJson() failed: "));
Serial.println(error.c_str());
return;
}
// Extract values
Serial.println(F("Response:"));
Serial.println(doc["sensor"].as<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
}
// 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 ❤❤❤❤❤

139
lib_standalone/ArduinoJson/extras/scripts/wandbox/JsonParserExample.cpp → lib/ArduinoJson/examples/JsonParserExample/JsonParserExample.ino
View File

@@ -1,59 +1,80 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
// //
// This example shows how to deserialize a JSON document with ArduinoJson. // This example shows how to deserialize a JSON document with ArduinoJson.
//
#include <iostream> // https://arduinojson.org/v6/example/parser/
#include "ArduinoJson.h"
#include <ArduinoJson.h>
int main() {
// Allocate the JSON document void setup() {
// // Initialize serial port
// Inside the brackets, 200 is the capacity of the memory pool in bytes. Serial.begin(9600);
// Don't forget to change this value to match your JSON document. while (!Serial) continue;
// Use arduinojson.org/v6/assistant to compute the capacity.
StaticJsonDocument<300> doc; // Allocate the JSON document
//
// StaticJsonDocument<N> allocates memory on the stack, it can be // Inside the brackets, 200 is the capacity of the memory pool in bytes.
// replaced by DynamicJsonDocument which allocates in the heap. // Don't forget to change this value to match your JSON document.
// // Use arduinojson.org/v6/assistant to compute the capacity.
// DynamicJsonDocument doc(200); StaticJsonDocument<200> doc;
// JSON input string. // StaticJsonDocument<N> allocates memory on the stack, it can be
// // replaced by DynamicJsonDocument which allocates in the heap.
// 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 // DynamicJsonDocument doc(200);
// the input buffer.
// If you use another type of input, ArduinoJson must copy the strings from // JSON input string.
// the input to the JsonDocument, so you need to increase the capacity of the //
// JsonDocument. // Using a char[], as shown here, enables the "zero-copy" mode. This mode uses
char json[] = // the minimal amount of memory because the JsonDocument stores pointers to
"{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}"; // the input buffer.
// If you use another type of input, ArduinoJson must copy the strings from
// Deserialize the JSON document // the input to the JsonDocument, so you need to increase the capacity of the
DeserializationError error = deserializeJson(doc, json); // JsonDocument.
char json[] =
// Test if parsing succeeds. "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
if (error) {
std::cerr << "deserializeJson() failed: " << error.c_str() << std::endl; // Deserialize the JSON document
return 1; DeserializationError error = deserializeJson(doc, json);
}
// Test if parsing succeeds.
// Fetch values. if (error) {
// Serial.print(F("deserializeJson() failed: "));
// Most of the time, you can rely on the implicit casts. Serial.println(error.c_str());
// In other case, you can do doc["time"].as<long>(); return;
const char* sensor = doc["sensor"]; }
long time = doc["time"];
double latitude = doc["data"][0]; // Fetch values.
double longitude = doc["data"][1]; //
// Most of the time, you can rely on the implicit casts.
// Print values. // In other case, you can do doc["time"].as<long>();
std::cout << sensor << std::endl; const char* sensor = doc["sensor"];
std::cout << time << std::endl; long time = doc["time"];
std::cout << latitude << std::endl; double latitude = doc["data"][0];
std::cout << longitude << std::endl; double longitude = doc["data"][1];
return 0; // Print values.
} Serial.println(sensor);
Serial.println(time);
Serial.println(latitude, 6);
Serial.println(longitude, 6);
}
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 ❤❤❤❤❤

110
lib/ArduinoJson/examples/JsonServer/JsonServer.ino Normal file
View File

@@ -0,0 +1,110 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020
// 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/
#include <ArduinoJson.h>
#include <Ethernet.h>
#include <SPI.h>
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
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;
}
// Start to listen
server.begin();
Serial.println(F("Server is ready."));
Serial.print(F("Please connect to http://"));
Serial.println(Ethernet.localIP());
}
void loop() {
// Wait for an incomming connection
EthernetClient client = server.available();
// 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 arduinojson.org/v6/assistant to compute the capacity.
StaticJsonDocument<500> doc;
// 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);
}
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();
}
// 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 ❤❤❤❤❤

100
lib/ArduinoJson/examples/JsonUdpBeacon/JsonUdpBeacon.ino Normal file
View File

@@ -0,0 +1,100 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020
// MIT License
//
// 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]
// }
//
// 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/
#include <ArduinoJson.h>
#include <Ethernet.h>
#include <SPI.h>
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress remoteIp(192, 168, 0, 108); // <- EDIT!!!!
unsigned short remotePort = 8888;
unsigned short localPort = 8888;
EthernetUDP udp;
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;
}
// Enable UDP
udp.begin(localPort);
}
void loop() {
// Allocate a temporary JsonDocument
// Use arduinojson.org/v6/assistant to compute the capacity.
StaticJsonDocument<500> doc;
// 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);
}
// 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 ❤❤❤❤❤

143
lib_standalone/ArduinoJson/extras/scripts/wandbox/MsgPackParserExample.cpp → lib/ArduinoJson/examples/MsgPackParser/MsgPackParser.ino
View File

@@ -1,68 +1,75 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
// //
// This example shows how to generate a JSON document with ArduinoJson. // This example shows how to deserialize a MessagePack document with
// ArduinoJson.
#include <iostream> //
#include "ArduinoJson.h" // https://arduinojson.org/v6/example/msgpack-parser/
int main() { #include <ArduinoJson.h>
// Allocate the JSON document
// void setup() {
// Inside the brackets, 300 is the size of the memory pool in bytes. // Initialize serial port
// Don't forget to change this value to match your JSON document. Serial.begin(9600);
// Use arduinojson.org/assistant to compute the capacity. while (!Serial) continue;
StaticJsonDocument<300> doc;
// Allocate the JSON document
// StaticJsonObject allocates memory on the stack, it can be //
// replaced by DynamicJsonObject which allocates in the heap. // 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.
// DynamicJsonObject doc(200); // Use arduinojson.org/v6/assistant to compute the capacity.
StaticJsonDocument<200> doc;
// MessagePack input string.
// // StaticJsonObject allocates memory on the stack, it can be
// It's better to use a char[] as shown here. // replaced by DynamicJsonObject which allocates in the heap.
// If you use a const char* or a String, ArduinoJson will //
// have to make a copy of the input in the JsonBuffer. // DynamicJsonObject doc(200);
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, // MessagePack input string.
97, 116, 97, 146, 203, 64, 72, 96, 199, 58, 188, 148, //
112, 203, 64, 2, 106, 146, 230, 33, 49, 169}; // Using a char[], as shown here, enables the "zero-copy" mode. This mode uses
// This MessagePack document contains: // the minimal amount of memory because the JsonDocument stores pointers to
// { // the input buffer.
// "sensor": "gps", // If you use another type of input, ArduinoJson must copy the strings from
// "time": 1351824120, // the input to the JsonDocument, so you need to increase the capacity of the
// "data": [48.75608, 2.302038] // 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,
// doc of the object tree. 97, 116, 97, 146, 203, 64, 72, 96, 199, 58, 188, 148,
// 112, 203, 64, 2, 106, 146, 230, 33, 49, 169};
// It's a reference to the JsonObject, the actual bytes are inside the // This MessagePack document contains:
// JsonBuffer with all the other nodes of the object tree. // {
// Memory is freed when jsonBuffer goes out of scope. // "sensor": "gps",
DeserializationError error = deserializeMsgPack(doc, input); // "time": 1351824120,
// "data": [48.75608, 2.302038]
// Test if parsing succeeds. // }
if (error) {
std::cerr << "deserializeMsgPack() failed: " << error.c_str() << std::endl; DeserializationError error = deserializeMsgPack(doc, input);
return 1;
} // Test if parsing succeeded.
if (error) {
// Fetch values. Serial.print("deserializeMsgPack() failed: ");
// Serial.println(error.c_str());
// Most of the time, you can rely on the implicit casts. return;
// In other case, you can do doc["time"].as<long>(); }
const char* sensor = doc["sensor"];
long time = doc["time"]; // Fetch values.
double latitude = doc["data"][0]; //
double longitude = doc["data"][1]; // Most of the time, you can rely on the implicit casts.
// In other case, you can do doc["time"].as<long>();
// Print values. const char* sensor = doc["sensor"];
std::cout << sensor << std::endl; long time = doc["time"];
std::cout << time << std::endl; double latitude = doc["data"][0];
std::cout << latitude << std::endl; double longitude = doc["data"][1];
std::cout << longitude << std::endl;
// Print values.
return 0; Serial.println(sensor);
} Serial.println(time);
Serial.println(latitude, 6);
Serial.println(longitude, 6);
}
void loop() {
// not used in this example
}

72
lib/ArduinoJson/examples/ProgmemExample/ProgmemExample.ino Normal file
View File

@@ -0,0 +1,72 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020
// 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() {
#ifdef PROGMEM // <- check that Flash strings are supported
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")) {
// ...
}
#else
#warning PROGMEM is not supported on this platform
#endif
}
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 ❤❤❤❤❤

77
lib/ArduinoJson/examples/StringExample/StringExample.ino Normal file
View File

@@ -0,0 +1,77 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020
// 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 ❤❤❤❤❤

78
lib_standalone/ArduinoJson/keywords.txt → lib/ArduinoJson/keywords.txt
View File

@@ -1,39 +1,39 @@
# Macros # Macros
JSON_ARRAY_SIZE KEYWORD2 JSON_ARRAY_SIZE KEYWORD2
JSON_OBJECT_SIZE KEYWORD2 JSON_OBJECT_SIZE KEYWORD2
JSON_STRING_SIZE KEYWORD2 JSON_STRING_SIZE KEYWORD2
# Free functions # Free functions
deserializeJson KEYWORD2 deserializeJson KEYWORD2
deserializeMsgPack KEYWORD2 deserializeMsgPack KEYWORD2
serialized KEYWORD2 serialized KEYWORD2
serializeJson KEYWORD2 serializeJson KEYWORD2
serializeJsonPretty KEYWORD2 serializeJsonPretty KEYWORD2
serializeMsgPack KEYWORD2 serializeMsgPack KEYWORD2
measureJson KEYWORD2 measureJson KEYWORD2
measureJsonPretty KEYWORD2 measureJsonPretty KEYWORD2
measureMsgPack KEYWORD2 measureMsgPack KEYWORD2
# Methods # Methods
add KEYWORD2 add KEYWORD2
as KEYWORD2 as KEYWORD2
createNestedArray KEYWORD2 createNestedArray KEYWORD2
createNestedObject KEYWORD2 createNestedObject KEYWORD2
get KEYWORD2 get KEYWORD2
set KEYWORD2 set KEYWORD2
to KEYWORD2 to KEYWORD2
# Type names # Type names
DeserializationError KEYWORD1 DATA_TYPE DeserializationError KEYWORD1 DATA_TYPE
DynamicJsonDocument KEYWORD1 DATA_TYPE DynamicJsonDocument KEYWORD1 DATA_TYPE
JsonArray KEYWORD1 DATA_TYPE JsonArray KEYWORD1 DATA_TYPE
JsonArrayConst KEYWORD1 DATA_TYPE JsonArrayConst KEYWORD1 DATA_TYPE
JsonFloat KEYWORD1 DATA_TYPE JsonFloat KEYWORD1 DATA_TYPE
JsonInteger KEYWORD1 DATA_TYPE JsonInteger KEYWORD1 DATA_TYPE
JsonObject KEYWORD1 DATA_TYPE JsonObject KEYWORD1 DATA_TYPE
JsonObjectConst KEYWORD1 DATA_TYPE JsonObjectConst KEYWORD1 DATA_TYPE
JsonString KEYWORD1 DATA_TYPE JsonString KEYWORD1 DATA_TYPE
JsonUInt KEYWORD1 DATA_TYPE JsonUInt KEYWORD1 DATA_TYPE
JsonVariant KEYWORD1 DATA_TYPE JsonVariant KEYWORD1 DATA_TYPE
JsonVariantConst KEYWORD1 DATA_TYPE JsonVariantConst KEYWORD1 DATA_TYPE
StaticJsonDocument KEYWORD1 DATA_TYPE StaticJsonDocument KEYWORD1 DATA_TYPE

22
lib_standalone/ArduinoJson/library.properties → lib/ArduinoJson/library.properties
View File

@@ -1,11 +1,11 @@
name=ArduinoJson name=ArduinoJson
version=6.15.0 version=6.16.1
author=Benoit Blanchon <blog.benoitblanchon.fr> author=Benoit Blanchon <blog.benoitblanchon.fr>
maintainer=Benoit Blanchon <blog.benoitblanchon.fr> maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
sentence=A simple and efficient JSON library for embedded C++. sentence=A simple and efficient JSON library for embedded C++.
paragraph=ArduinoJson supports ✔ serialization, ✔ deserialization, ✔ MessagePack, ✔ fixed allocation, ✔ zero-copy, ✔ streams, ✔ filtering, and more. It is the most popular Arduino library on GitHub ❤❤❤❤❤. Check out arduinojson.org for a comprehensive documentation. paragraph=ArduinoJson supports ✔ serialization, ✔ deserialization, ✔ MessagePack, ✔ fixed allocation, ✔ zero-copy, ✔ streams, ✔ filtering, and more. It is the most popular Arduino library on GitHub ❤❤❤❤❤. Check out arduinojson.org for a comprehensive documentation.
category=Data Processing category=Data Processing
url=https://arduinojson.org/?utm_source=meta&utm_medium=library.properties url=https://arduinojson.org/?utm_source=meta&utm_medium=library.properties
architectures=* architectures=*
repository=https://github.com/bblanchon/ArduinoJson.git repository=https://github.com/bblanchon/ArduinoJson.git
license=MIT license=MIT

34
lib_standalone/ArduinoJson/src/ArduinoJson.h → lib/ArduinoJson/src/ArduinoJson.h
View File

@@ -1,17 +1,17 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#ifdef __cplusplus #ifdef __cplusplus
#include "ArduinoJson.hpp" #include "ArduinoJson.hpp"
using namespace ArduinoJson; using namespace ArduinoJson;
#else #else
#error ArduinoJson requires a C++ compiler, please change file extension to .cc or .cpp #error ArduinoJson requires a C++ compiler, please change file extension to .cc or .cpp
#endif #endif

145
lib_standalone/ArduinoJson/src/ArduinoJson.hpp → lib/ArduinoJson/src/ArduinoJson.hpp
View File

@@ -1,72 +1,73 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include "ArduinoJson/Configuration.hpp" #include "ArduinoJson/Configuration.hpp"
#if !ARDUINOJSON_DEBUG #if !ARDUINOJSON_DEBUG
#ifdef __clang__ #ifdef __clang__
#pragma clang system_header #pragma clang system_header
#elif defined __GNUC__ #elif defined __GNUC__
#pragma GCC system_header #pragma GCC system_header
#endif #endif
#endif #endif
#include "ArduinoJson/Array/ArrayRef.hpp" #include "ArduinoJson/Array/ArrayRef.hpp"
#include "ArduinoJson/Object/ObjectRef.hpp" #include "ArduinoJson/Object/ObjectRef.hpp"
#include "ArduinoJson/Variant/VariantRef.hpp" #include "ArduinoJson/Variant/VariantRef.hpp"
#include "ArduinoJson/Document/DynamicJsonDocument.hpp" #include "ArduinoJson/Document/DynamicJsonDocument.hpp"
#include "ArduinoJson/Document/StaticJsonDocument.hpp" #include "ArduinoJson/Document/StaticJsonDocument.hpp"
#include "ArduinoJson/Array/ArrayImpl.hpp" #include "ArduinoJson/Array/ArrayImpl.hpp"
#include "ArduinoJson/Array/ElementProxy.hpp" #include "ArduinoJson/Array/ElementProxy.hpp"
#include "ArduinoJson/Array/Utilities.hpp" #include "ArduinoJson/Array/Utilities.hpp"
#include "ArduinoJson/Collection/CollectionImpl.hpp" #include "ArduinoJson/Collection/CollectionImpl.hpp"
#include "ArduinoJson/Object/MemberProxy.hpp" #include "ArduinoJson/Object/MemberProxy.hpp"
#include "ArduinoJson/Object/ObjectImpl.hpp" #include "ArduinoJson/Object/ObjectImpl.hpp"
#include "ArduinoJson/Variant/VariantAsImpl.hpp" #include "ArduinoJson/Variant/VariantAsImpl.hpp"
#include "ArduinoJson/Variant/VariantImpl.hpp" #include "ArduinoJson/Variant/VariantCompare.hpp"
#include "ArduinoJson/Variant/VariantImpl.hpp"
#include "ArduinoJson/Json/JsonDeserializer.hpp"
#include "ArduinoJson/Json/JsonSerializer.hpp" #include "ArduinoJson/Json/JsonDeserializer.hpp"
#include "ArduinoJson/Json/PrettyJsonSerializer.hpp" #include "ArduinoJson/Json/JsonSerializer.hpp"
#include "ArduinoJson/MsgPack/MsgPackDeserializer.hpp" #include "ArduinoJson/Json/PrettyJsonSerializer.hpp"
#include "ArduinoJson/MsgPack/MsgPackSerializer.hpp" #include "ArduinoJson/MsgPack/MsgPackDeserializer.hpp"
#include "ArduinoJson/MsgPack/MsgPackSerializer.hpp"
#include "ArduinoJson/compatibility.hpp"
#include "ArduinoJson/compatibility.hpp"
namespace ArduinoJson {
typedef ARDUINOJSON_NAMESPACE::ArrayConstRef JsonArrayConst; namespace ArduinoJson {
typedef ARDUINOJSON_NAMESPACE::ArrayRef JsonArray; typedef ARDUINOJSON_NAMESPACE::ArrayConstRef JsonArrayConst;
typedef ARDUINOJSON_NAMESPACE::Float JsonFloat; typedef ARDUINOJSON_NAMESPACE::ArrayRef JsonArray;
typedef ARDUINOJSON_NAMESPACE::Integer JsonInteger; typedef ARDUINOJSON_NAMESPACE::Float JsonFloat;
typedef ARDUINOJSON_NAMESPACE::ObjectConstRef JsonObjectConst; typedef ARDUINOJSON_NAMESPACE::Integer JsonInteger;
typedef ARDUINOJSON_NAMESPACE::ObjectRef JsonObject; typedef ARDUINOJSON_NAMESPACE::ObjectConstRef JsonObjectConst;
typedef ARDUINOJSON_NAMESPACE::Pair JsonPair; typedef ARDUINOJSON_NAMESPACE::ObjectRef JsonObject;
typedef ARDUINOJSON_NAMESPACE::PairConst JsonPairConst; typedef ARDUINOJSON_NAMESPACE::Pair JsonPair;
typedef ARDUINOJSON_NAMESPACE::String JsonString; typedef ARDUINOJSON_NAMESPACE::PairConst JsonPairConst;
typedef ARDUINOJSON_NAMESPACE::UInt JsonUInt; typedef ARDUINOJSON_NAMESPACE::String JsonString;
typedef ARDUINOJSON_NAMESPACE::VariantConstRef JsonVariantConst; typedef ARDUINOJSON_NAMESPACE::UInt JsonUInt;
typedef ARDUINOJSON_NAMESPACE::VariantRef JsonVariant; typedef ARDUINOJSON_NAMESPACE::VariantConstRef JsonVariantConst;
using ARDUINOJSON_NAMESPACE::BasicJsonDocument; typedef ARDUINOJSON_NAMESPACE::VariantRef JsonVariant;
using ARDUINOJSON_NAMESPACE::copyArray; using ARDUINOJSON_NAMESPACE::BasicJsonDocument;
using ARDUINOJSON_NAMESPACE::DeserializationError; using ARDUINOJSON_NAMESPACE::copyArray;
using ARDUINOJSON_NAMESPACE::deserializeJson; using ARDUINOJSON_NAMESPACE::DeserializationError;
using ARDUINOJSON_NAMESPACE::deserializeMsgPack; using ARDUINOJSON_NAMESPACE::deserializeJson;
using ARDUINOJSON_NAMESPACE::DynamicJsonDocument; using ARDUINOJSON_NAMESPACE::deserializeMsgPack;
using ARDUINOJSON_NAMESPACE::JsonDocument; using ARDUINOJSON_NAMESPACE::DynamicJsonDocument;
using ARDUINOJSON_NAMESPACE::measureJson; using ARDUINOJSON_NAMESPACE::JsonDocument;
using ARDUINOJSON_NAMESPACE::serialized; using ARDUINOJSON_NAMESPACE::measureJson;
using ARDUINOJSON_NAMESPACE::serializeJson; using ARDUINOJSON_NAMESPACE::serialized;
using ARDUINOJSON_NAMESPACE::serializeJsonPretty; using ARDUINOJSON_NAMESPACE::serializeJson;
using ARDUINOJSON_NAMESPACE::serializeMsgPack; using ARDUINOJSON_NAMESPACE::serializeJsonPretty;
using ARDUINOJSON_NAMESPACE::StaticJsonDocument; using ARDUINOJSON_NAMESPACE::serializeMsgPack;
using ARDUINOJSON_NAMESPACE::StaticJsonDocument;
namespace DeserializationOption {
using ARDUINOJSON_NAMESPACE::Filter; namespace DeserializationOption {
using ARDUINOJSON_NAMESPACE::NestingLimit; using ARDUINOJSON_NAMESPACE::Filter;
} // namespace DeserializationOption using ARDUINOJSON_NAMESPACE::NestingLimit;
} // namespace ArduinoJson } // namespace DeserializationOption
} // namespace ArduinoJson

60
lib_standalone/ArduinoJson/src/ArduinoJson/Array/ArrayFunctions.hpp → lib/ArduinoJson/src/ArduinoJson/Array/ArrayFunctions.hpp
View File

@@ -1,30 +1,30 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Collection/CollectionData.hpp> #include <ArduinoJson/Collection/CollectionData.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
inline VariantData *arrayAdd(CollectionData *arr, MemoryPool *pool) { inline VariantData *arrayAdd(CollectionData *arr, MemoryPool *pool) {
return arr ? arr->addElement(pool) : 0; return arr ? arr->addElement(pool) : 0;
} }
template <typename Visitor> template <typename Visitor>
inline void arrayAccept(const CollectionData *arr, Visitor &visitor) { inline void arrayAccept(const CollectionData *arr, Visitor &visitor) {
if (arr) if (arr)
visitor.visitArray(*arr); visitor.visitArray(*arr);
else else
visitor.visitNull(); visitor.visitNull();
} }
inline bool arrayEquals(const CollectionData *lhs, const CollectionData *rhs) { inline bool arrayEquals(const CollectionData *lhs, const CollectionData *rhs) {
if (lhs == rhs) if (lhs == rhs)
return true; return true;
if (!lhs || !rhs) if (!lhs || !rhs)
return false; return false;
return lhs->equalsArray(*rhs); return lhs->equalsArray(*rhs);
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

56
lib_standalone/ArduinoJson/src/ArduinoJson/Array/ArrayImpl.hpp → lib/ArduinoJson/src/ArduinoJson/Array/ArrayImpl.hpp
View File

@@ -1,28 +1,28 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Array/ArrayRef.hpp> #include <ArduinoJson/Array/ArrayRef.hpp>
#include <ArduinoJson/Object/ObjectRef.hpp> #include <ArduinoJson/Object/ObjectRef.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TArray> template <typename TArray>
inline ArrayRef ArrayShortcuts<TArray>::createNestedArray() const { inline ArrayRef ArrayShortcuts<TArray>::createNestedArray() const {
return impl()->addElement().template to<ArrayRef>(); return impl()->addElement().template to<ArrayRef>();
} }
template <typename TArray> template <typename TArray>
inline ObjectRef ArrayShortcuts<TArray>::createNestedObject() const { inline ObjectRef ArrayShortcuts<TArray>::createNestedObject() const {
return impl()->addElement().template to<ObjectRef>(); return impl()->addElement().template to<ObjectRef>();
} }
template <typename TArray> template <typename TArray>
inline ElementProxy<TArray> ArrayShortcuts<TArray>::operator[]( inline ElementProxy<TArray> ArrayShortcuts<TArray>::operator[](
size_t index) const { size_t index) const {
return ElementProxy<TArray>(*impl(), index); return ElementProxy<TArray>(*impl(), index);
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

242
lib_standalone/ArduinoJson/src/ArduinoJson/Array/ArrayIterator.hpp → lib/ArduinoJson/src/ArduinoJson/Array/ArrayIterator.hpp
View File

@@ -1,121 +1,121 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Variant/SlotFunctions.hpp> #include <ArduinoJson/Variant/SlotFunctions.hpp>
#include <ArduinoJson/Variant/VariantRef.hpp> #include <ArduinoJson/Variant/VariantRef.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
class VariantPtr { class VariantPtr {
public: public:
VariantPtr(MemoryPool *pool, VariantData *data) : _variant(pool, data) {} VariantPtr(MemoryPool *pool, VariantData *data) : _variant(pool, data) {}
VariantRef *operator->() { VariantRef *operator->() {
return &_variant; return &_variant;
} }
VariantRef &operator*() { VariantRef &operator*() {
return _variant; return _variant;
} }
private: private:
VariantRef _variant; VariantRef _variant;
}; };
class ArrayIterator { class ArrayIterator {
public: public:
ArrayIterator() : _slot(0) {} ArrayIterator() : _slot(0) {}
explicit ArrayIterator(MemoryPool *pool, VariantSlot *slot) explicit ArrayIterator(MemoryPool *pool, VariantSlot *slot)
: _pool(pool), _slot(slot) {} : _pool(pool), _slot(slot) {}
VariantRef operator*() const { VariantRef operator*() const {
return VariantRef(_pool, _slot->data()); return VariantRef(_pool, _slot->data());
} }
VariantPtr operator->() { VariantPtr operator->() {
return VariantPtr(_pool, _slot->data()); return VariantPtr(_pool, _slot->data());
} }
bool operator==(const ArrayIterator &other) const { bool operator==(const ArrayIterator &other) const {
return _slot == other._slot; return _slot == other._slot;
} }
bool operator!=(const ArrayIterator &other) const { bool operator!=(const ArrayIterator &other) const {
return _slot != other._slot; return _slot != other._slot;
} }
ArrayIterator &operator++() { ArrayIterator &operator++() {
_slot = _slot->next(); _slot = _slot->next();
return *this; return *this;
} }
ArrayIterator &operator+=(size_t distance) { ArrayIterator &operator+=(size_t distance) {
_slot = _slot->next(distance); _slot = _slot->next(distance);
return *this; return *this;
} }
VariantSlot *internal() { VariantSlot *internal() {
return _slot; return _slot;
} }
private: private:
MemoryPool *_pool; MemoryPool *_pool;
VariantSlot *_slot; VariantSlot *_slot;
}; };
class VariantConstPtr { class VariantConstPtr {
public: public:
VariantConstPtr(const VariantData *data) : _variant(data) {} VariantConstPtr(const VariantData *data) : _variant(data) {}
VariantConstRef *operator->() { VariantConstRef *operator->() {
return &_variant; return &_variant;
} }
VariantConstRef &operator*() { VariantConstRef &operator*() {
return _variant; return _variant;
} }
private: private:
VariantConstRef _variant; VariantConstRef _variant;
}; };
class ArrayConstRefIterator { class ArrayConstRefIterator {
public: public:
ArrayConstRefIterator() : _slot(0) {} ArrayConstRefIterator() : _slot(0) {}
explicit ArrayConstRefIterator(const VariantSlot *slot) : _slot(slot) {} explicit ArrayConstRefIterator(const VariantSlot *slot) : _slot(slot) {}
VariantConstRef operator*() const { VariantConstRef operator*() const {
return VariantConstRef(_slot->data()); return VariantConstRef(_slot->data());
} }
VariantConstPtr operator->() { VariantConstPtr operator->() {
return VariantConstPtr(_slot->data()); return VariantConstPtr(_slot->data());
} }
bool operator==(const ArrayConstRefIterator &other) const { bool operator==(const ArrayConstRefIterator &other) const {
return _slot == other._slot; return _slot == other._slot;
} }
bool operator!=(const ArrayConstRefIterator &other) const { bool operator!=(const ArrayConstRefIterator &other) const {
return _slot != other._slot; return _slot != other._slot;
} }
ArrayConstRefIterator &operator++() { ArrayConstRefIterator &operator++() {
_slot = _slot->next(); _slot = _slot->next();
return *this; return *this;
} }
ArrayConstRefIterator &operator+=(size_t distance) { ArrayConstRefIterator &operator+=(size_t distance) {
_slot = _slot->next(distance); _slot = _slot->next(distance);
return *this; return *this;
} }
const VariantSlot *internal() { const VariantSlot *internal() {
return _slot; return _slot;
} }
private: private:
const VariantSlot *_slot; const VariantSlot *_slot;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

334
lib_standalone/ArduinoJson/src/ArduinoJson/Array/ArrayRef.hpp → lib/ArduinoJson/src/ArduinoJson/Array/ArrayRef.hpp
View File

@@ -1,167 +1,167 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Array/ArrayFunctions.hpp> #include <ArduinoJson/Array/ArrayFunctions.hpp>
#include <ArduinoJson/Array/ArrayIterator.hpp> #include <ArduinoJson/Array/ArrayIterator.hpp>
#include <ArduinoJson/Variant/VariantData.hpp> #include <ArduinoJson/Variant/VariantData.hpp>
// Returns the size (in bytes) of an array with n elements. // Returns the size (in bytes) of an array with n elements.
// Can be very handy to determine the size of a StaticMemoryPool. // Can be very handy to determine the size of a StaticMemoryPool.
#define JSON_ARRAY_SIZE(NUMBER_OF_ELEMENTS) \ #define JSON_ARRAY_SIZE(NUMBER_OF_ELEMENTS) \
((NUMBER_OF_ELEMENTS) * sizeof(ARDUINOJSON_NAMESPACE::VariantSlot)) ((NUMBER_OF_ELEMENTS) * sizeof(ARDUINOJSON_NAMESPACE::VariantSlot))
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
class ObjectRef; class ObjectRef;
template <typename> template <typename>
class ElementProxy; class ElementProxy;
template <typename TData> template <typename TData>
class ArrayRefBase { class ArrayRefBase {
public: public:
operator VariantConstRef() const { operator VariantConstRef() const {
const void* data = _data; // prevent warning cast-align const void* data = _data; // prevent warning cast-align
return VariantConstRef(reinterpret_cast<const VariantData*>(data)); return VariantConstRef(reinterpret_cast<const VariantData*>(data));
} }
template <typename Visitor> template <typename Visitor>
FORCE_INLINE void accept(Visitor& visitor) const { FORCE_INLINE void accept(Visitor& visitor) const {
arrayAccept(_data, visitor); arrayAccept(_data, visitor);
} }
FORCE_INLINE bool isNull() const { FORCE_INLINE bool isNull() const {
return _data == 0; return _data == 0;
} }
FORCE_INLINE operator bool() const { FORCE_INLINE operator bool() const {
return _data != 0; return _data != 0;
} }
FORCE_INLINE size_t memoryUsage() const { FORCE_INLINE size_t memoryUsage() const {
return _data ? _data->memoryUsage() : 0; return _data ? _data->memoryUsage() : 0;
} }
FORCE_INLINE size_t nesting() const { FORCE_INLINE size_t nesting() const {
return _data ? _data->nesting() : 0; return _data ? _data->nesting() : 0;
} }
FORCE_INLINE size_t size() const { FORCE_INLINE size_t size() const {
return _data ? _data->size() : 0; return _data ? _data->size() : 0;
} }
protected: protected:
ArrayRefBase(TData* data) : _data(data) {} ArrayRefBase(TData* data) : _data(data) {}
TData* _data; TData* _data;
}; };
class ArrayConstRef : public ArrayRefBase<const CollectionData>, class ArrayConstRef : public ArrayRefBase<const CollectionData>,
public Visitable { public Visitable {
friend class ArrayRef; friend class ArrayRef;
typedef ArrayRefBase<const CollectionData> base_type; typedef ArrayRefBase<const CollectionData> base_type;
public: public:
typedef ArrayConstRefIterator iterator; typedef ArrayConstRefIterator iterator;
FORCE_INLINE iterator begin() const { FORCE_INLINE iterator begin() const {
if (!_data) if (!_data)
return iterator(); return iterator();
return iterator(_data->head()); return iterator(_data->head());
} }
FORCE_INLINE iterator end() const { FORCE_INLINE iterator end() const {
return iterator(); return iterator();
} }
FORCE_INLINE ArrayConstRef() : base_type(0) {} FORCE_INLINE ArrayConstRef() : base_type(0) {}
FORCE_INLINE ArrayConstRef(const CollectionData* data) : base_type(data) {} FORCE_INLINE ArrayConstRef(const CollectionData* data) : base_type(data) {}
FORCE_INLINE bool operator==(ArrayConstRef rhs) const { FORCE_INLINE bool operator==(ArrayConstRef rhs) const {
return arrayEquals(_data, rhs._data); return arrayEquals(_data, rhs._data);
} }
FORCE_INLINE VariantConstRef operator[](size_t index) const { FORCE_INLINE VariantConstRef operator[](size_t index) const {
return getElement(index); return getElement(index);
} }
FORCE_INLINE VariantConstRef getElement(size_t index) const { FORCE_INLINE VariantConstRef getElement(size_t index) const {
return VariantConstRef(_data ? _data->getElement(index) : 0); return VariantConstRef(_data ? _data->getElement(index) : 0);
} }
}; };
class ArrayRef : public ArrayRefBase<CollectionData>, class ArrayRef : public ArrayRefBase<CollectionData>,
public ArrayShortcuts<ArrayRef>, public ArrayShortcuts<ArrayRef>,
public Visitable { public Visitable {
typedef ArrayRefBase<CollectionData> base_type; typedef ArrayRefBase<CollectionData> base_type;
public: public:
typedef ArrayIterator iterator; typedef ArrayIterator iterator;
FORCE_INLINE ArrayRef() : base_type(0), _pool(0) {} FORCE_INLINE ArrayRef() : base_type(0), _pool(0) {}
FORCE_INLINE ArrayRef(MemoryPool* pool, CollectionData* data) FORCE_INLINE ArrayRef(MemoryPool* pool, CollectionData* data)
: base_type(data), _pool(pool) {} : base_type(data), _pool(pool) {}
operator VariantRef() { operator VariantRef() {
void* data = _data; // prevent warning cast-align void* data = _data; // prevent warning cast-align
return VariantRef(_pool, reinterpret_cast<VariantData*>(data)); return VariantRef(_pool, reinterpret_cast<VariantData*>(data));
} }
operator ArrayConstRef() const { operator ArrayConstRef() const {
return ArrayConstRef(_data); return ArrayConstRef(_data);
} }
VariantRef addElement() const { VariantRef addElement() const {
return VariantRef(_pool, arrayAdd(_data, _pool)); return VariantRef(_pool, arrayAdd(_data, _pool));
} }
FORCE_INLINE iterator begin() const { FORCE_INLINE iterator begin() const {
if (!_data) if (!_data)
return iterator(); return iterator();
return iterator(_pool, _data->head()); return iterator(_pool, _data->head());
} }
FORCE_INLINE iterator end() const { FORCE_INLINE iterator end() const {
return iterator(); return iterator();
} }
// Copy a ArrayRef // Copy a ArrayRef
FORCE_INLINE bool set(ArrayConstRef src) const { FORCE_INLINE bool set(ArrayConstRef src) const {
if (!_data || !src._data) if (!_data || !src._data)
return false; return false;
return _data->copyFrom(*src._data, _pool); return _data->copyFrom(*src._data, _pool);
} }
FORCE_INLINE bool operator==(ArrayRef rhs) const { FORCE_INLINE bool operator==(ArrayRef rhs) const {
return arrayEquals(_data, rhs._data); return arrayEquals(_data, rhs._data);
} }
// Internal use // Internal use
FORCE_INLINE VariantRef getOrAddElement(size_t index) const { FORCE_INLINE VariantRef getOrAddElement(size_t index) const {
return VariantRef(_pool, _data ? _data->getOrAddElement(index, _pool) : 0); return VariantRef(_pool, _data ? _data->getOrAddElement(index, _pool) : 0);
} }
// Gets the value at the specified index. // Gets the value at the specified index.
FORCE_INLINE VariantRef getElement(size_t index) const { FORCE_INLINE VariantRef getElement(size_t index) const {
return VariantRef(_pool, _data ? _data->getElement(index) : 0); return VariantRef(_pool, _data ? _data->getElement(index) : 0);
} }
// Removes element at specified position. // Removes element at specified position.
FORCE_INLINE void remove(iterator it) const { FORCE_INLINE void remove(iterator it) const {
if (!_data) if (!_data)
return; return;
_data->removeSlot(it.internal()); _data->removeSlot(it.internal());
} }
// Removes element at specified index. // Removes element at specified index.
FORCE_INLINE void remove(size_t index) const { FORCE_INLINE void remove(size_t index) const {
if (!_data) if (!_data)
return; return;
_data->removeElement(index); _data->removeElement(index);
} }
private: private:
MemoryPool* _pool; MemoryPool* _pool;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

94
lib_standalone/ArduinoJson/src/ArduinoJson/Array/ArrayShortcuts.hpp → lib/ArduinoJson/src/ArduinoJson/Array/ArrayShortcuts.hpp
View File

@@ -1,47 +1,47 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Polyfills/attributes.hpp> #include <ArduinoJson/Polyfills/attributes.hpp>
#include <ArduinoJson/Polyfills/type_traits.hpp> #include <ArduinoJson/Polyfills/type_traits.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
// Forward declarations. // Forward declarations.
template <typename> template <typename>
class ElementProxy; class ElementProxy;
template <typename TArray> template <typename TArray>
class ArrayShortcuts { class ArrayShortcuts {
public: public:
// Returns the element at specified index if the variant is an array. // Returns the element at specified index if the variant is an array.
FORCE_INLINE ElementProxy<TArray> operator[](size_t index) const; FORCE_INLINE ElementProxy<TArray> operator[](size_t index) const;
FORCE_INLINE ObjectRef createNestedObject() const; FORCE_INLINE ObjectRef createNestedObject() const;
FORCE_INLINE ArrayRef createNestedArray() const; FORCE_INLINE ArrayRef createNestedArray() const;
// Adds the specified value at the end of the array. // Adds the specified value at the end of the array.
// //
// bool add(TValue); // bool add(TValue);
// TValue = bool, long, int, short, float, double, serialized, VariantRef, // TValue = bool, long, int, short, float, double, serialized, VariantRef,
// std::string, String, ObjectRef // std::string, String, ObjectRef
template <typename T> template <typename T>
FORCE_INLINE bool add(const T &value) const { FORCE_INLINE bool add(const T &value) const {
return impl()->addElement().set(value); return impl()->addElement().set(value);
} }
// //
// bool add(TValue); // bool add(TValue);
// TValue = char*, const char*, const __FlashStringHelper* // TValue = char*, const char*, const __FlashStringHelper*
template <typename T> template <typename T>
FORCE_INLINE bool add(T *value) const { FORCE_INLINE bool add(T *value) const {
return impl()->addElement().set(value); return impl()->addElement().set(value);
} }
private: private:
const TArray *impl() const { const TArray *impl() const {
return static_cast<const TArray *>(this); return static_cast<const TArray *>(this);
} }
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

353
lib_standalone/ArduinoJson/src/ArduinoJson/Array/ElementProxy.hpp → lib/ArduinoJson/src/ArduinoJson/Array/ElementProxy.hpp
View File

@@ -1,175 +1,178 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Configuration.hpp> #include <ArduinoJson/Configuration.hpp>
#include <ArduinoJson/Operators/VariantOperators.hpp> #include <ArduinoJson/Variant/VariantOperators.hpp>
#include <ArduinoJson/Variant/VariantTo.hpp> #include <ArduinoJson/Variant/VariantShortcuts.hpp>
#include <ArduinoJson/Variant/VariantTo.hpp>
#ifdef _MSC_VER
#pragma warning(push) #ifdef _MSC_VER
#pragma warning(disable : 4522) #pragma warning(push)
#endif #pragma warning(disable : 4522)
#endif
namespace ARDUINOJSON_NAMESPACE {
namespace ARDUINOJSON_NAMESPACE {
template <typename TArray>
class ElementProxy : public VariantOperators<ElementProxy<TArray> >, template <typename TArray>
public Visitable { class ElementProxy : public VariantOperators<ElementProxy<TArray> >,
typedef ElementProxy<TArray> this_type; public VariantShortcuts<ElementProxy<TArray> >,
public Visitable {
public: typedef ElementProxy<TArray> this_type;
FORCE_INLINE ElementProxy(TArray array, size_t index)
: _array(array), _index(index) {} public:
FORCE_INLINE ElementProxy(TArray array, size_t index)
FORCE_INLINE ElementProxy(const ElementProxy& src) : _array(array), _index(index) {}
: _array(src._array), _index(src._index) {}
FORCE_INLINE ElementProxy(const ElementProxy& src)
FORCE_INLINE this_type& operator=(const this_type& src) { : _array(src._array), _index(src._index) {}
getOrAddUpstreamElement().set(src.as<VariantConstRef>());
return *this; FORCE_INLINE this_type& operator=(const this_type& src) {
} getOrAddUpstreamElement().set(src.as<VariantConstRef>());
return *this;
// Replaces the value }
//
// operator=(const TValue&) // Replaces the value
// TValue = bool, long, int, short, float, double, serialized, VariantRef, //
// std::string, String, ArrayRef, ObjectRef // operator=(const TValue&)
template <typename T> // TValue = bool, long, int, short, float, double, serialized, VariantRef,
FORCE_INLINE this_type& operator=(const T& src) { // std::string, String, ArrayRef, ObjectRef
getOrAddUpstreamElement().set(src); template <typename T>
return *this; FORCE_INLINE this_type& operator=(const T& src) {
} getOrAddUpstreamElement().set(src);
// return *this;
// operator=(TValue) }
// TValue = char*, const char*, const __FlashStringHelper* //
template <typename T> // operator=(TValue)
FORCE_INLINE this_type& operator=(T* src) { // TValue = char*, const char*, const __FlashStringHelper*
getOrAddUpstreamElement().set(src); template <typename T>
return *this; FORCE_INLINE this_type& operator=(T* src) {
} getOrAddUpstreamElement().set(src);
return *this;
FORCE_INLINE bool operator==(VariantConstRef rhs) const { }
return static_cast<VariantConstRef>(getUpstreamElement()) == rhs;
} FORCE_INLINE void clear() const {
getUpstreamElement().clear();
FORCE_INLINE bool operator!=(VariantConstRef rhs) const { }
return static_cast<VariantConstRef>(getUpstreamElement()) != rhs;
} FORCE_INLINE bool isNull() const {
return getUpstreamElement().isNull();
FORCE_INLINE void clear() const { }
getUpstreamElement().clear();
} template <typename T>
FORCE_INLINE typename VariantAs<T>::type as() const {
FORCE_INLINE bool isNull() const { return getUpstreamElement().template as<T>();
return getUpstreamElement().isNull(); }
}
template <typename T>
template <typename T> FORCE_INLINE operator T() const {
FORCE_INLINE typename VariantAs<T>::type as() const { return getUpstreamElement();
return getUpstreamElement().template as<T>(); }
}
template <typename T>
template <typename T> FORCE_INLINE bool is() const {
FORCE_INLINE bool is() const { return getUpstreamElement().template is<T>();
return getUpstreamElement().template is<T>(); }
}
template <typename T>
template <typename T> FORCE_INLINE typename VariantTo<T>::type to() const {
FORCE_INLINE typename VariantTo<T>::type to() const { return getOrAddUpstreamElement().template to<T>();
return getOrAddUpstreamElement().template to<T>(); }
}
// Replaces the value
// Replaces the value //
// // bool set(const TValue&)
// bool set(const TValue&) // TValue = bool, long, int, short, float, double, serialized, VariantRef,
// TValue = bool, long, int, short, float, double, serialized, VariantRef, // std::string, String, ArrayRef, ObjectRef
// std::string, String, ArrayRef, ObjectRef template <typename TValue>
template <typename TValue> FORCE_INLINE bool set(const TValue& value) const {
FORCE_INLINE bool set(const TValue& value) const { return getOrAddUpstreamElement().set(value);
return getOrAddUpstreamElement().set(value); }
} //
// // bool set(TValue)
// bool set(TValue) // TValue = char*, const char*, const __FlashStringHelper*
// TValue = char*, const char*, const __FlashStringHelper* template <typename TValue>
template <typename TValue> FORCE_INLINE bool set(TValue* value) const {
FORCE_INLINE bool set(TValue* value) const { return getOrAddUpstreamElement().set(value);
return getOrAddUpstreamElement().set(value); }
}
template <typename Visitor>
template <typename Visitor> void accept(Visitor& visitor) const {
void accept(Visitor& visitor) const { return getUpstreamElement().accept(visitor);
return getUpstreamElement().accept(visitor); }
}
FORCE_INLINE size_t size() const {
FORCE_INLINE size_t size() const { return getUpstreamElement().size();
return getUpstreamElement().size(); }
}
template <typename TNestedKey>
template <typename TNestedKey> VariantRef getMember(TNestedKey* key) const {
VariantRef getMember(TNestedKey* key) const { return getUpstreamElement().getMember(key);
return getUpstreamElement().getMember(key); }
}
template <typename TNestedKey>
template <typename TNestedKey> VariantRef getMember(const TNestedKey& key) const {
VariantRef getMember(const TNestedKey& key) const { return getUpstreamElement().getMember(key);
return getUpstreamElement().getMember(key); }
}
template <typename TNestedKey>
template <typename TNestedKey> VariantRef getOrAddMember(TNestedKey* key) const {
VariantRef getOrAddMember(TNestedKey* key) const { return getOrAddUpstreamElement().getOrAddMember(key);
return getOrAddUpstreamElement().getOrAddMember(key); }
}
template <typename TNestedKey>
template <typename TNestedKey> VariantRef getOrAddMember(const TNestedKey& key) const {
VariantRef getOrAddMember(const TNestedKey& key) const { return getOrAddUpstreamElement().getOrAddMember(key);
return getOrAddUpstreamElement().getOrAddMember(key); }
}
VariantRef addElement() const {
VariantRef addElement() const { return getOrAddUpstreamElement().addElement();
return getOrAddUpstreamElement().addElement(); }
}
VariantRef getElement(size_t index) const {
VariantRef getElement(size_t index) const { return getOrAddUpstreamElement().getElement(index);
return getOrAddUpstreamElement().getElement(index); }
}
VariantRef getOrAddElement(size_t index) const {
FORCE_INLINE void remove(size_t index) const { return getOrAddUpstreamElement().getOrAddElement(index);
getUpstreamElement().remove(index); }
}
// remove(char*) const FORCE_INLINE void remove(size_t index) const {
// remove(const char*) const getUpstreamElement().remove(index);
// remove(const __FlashStringHelper*) const }
template <typename TChar> // remove(char*) const
FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove( // remove(const char*) const
TChar* key) const { // remove(const __FlashStringHelper*) const
getUpstreamElement().remove(key); template <typename TChar>
} FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
// remove(const std::string&) const TChar* key) const {
// remove(const String&) const getUpstreamElement().remove(key);
template <typename TString> }
FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove( // remove(const std::string&) const
const TString& key) const { // remove(const String&) const
getUpstreamElement().remove(key); template <typename TString>
} FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
const TString& key) const {
private: getUpstreamElement().remove(key);
FORCE_INLINE VariantRef getUpstreamElement() const { }
return _array.getElement(_index);
} private:
FORCE_INLINE VariantRef getUpstreamElement() const {
FORCE_INLINE VariantRef getOrAddUpstreamElement() const { return _array.getElement(_index);
return _array.getOrAddElement(_index); }
}
FORCE_INLINE VariantRef getOrAddUpstreamElement() const {
TArray _array; return _array.getOrAddElement(_index);
const size_t _index; }
};
TArray _array;
} // namespace ARDUINOJSON_NAMESPACE const size_t _index;
};
#ifdef _MSC_VER
#pragma warning(pop) } // namespace ARDUINOJSON_NAMESPACE
#endif
#ifdef _MSC_VER
#pragma warning(pop)
#endif

150
lib/ArduinoJson/src/ArduinoJson/Array/Utilities.hpp Normal file
View File

@@ -0,0 +1,150 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020
// MIT License
#pragma once
#include <ArduinoJson/Array/ArrayRef.hpp>
#include <ArduinoJson/Document/JsonDocument.hpp>
namespace ARDUINOJSON_NAMESPACE {
// Copy a 1D array to a JsonArray
template <typename T, size_t N, typename TDestination>
inline typename enable_if<!is_array<T>::value &&
!is_base_of<JsonDocument, TDestination>::value,
bool>::type
copyArray(T (&src)[N], const TDestination& dst) {
return copyArray(src, N, dst);
}
// Copy a 1D array to a JsonDocument
template <typename T, size_t N>
inline bool copyArray(T (&src)[N], JsonDocument& dst) {
return copyArray(src, dst.to<ArrayRef>());
}
// Copy a 1D array to a JsonArray
template <typename T, typename TDestination>
inline typename enable_if<!is_array<T>::value &&
!is_base_of<JsonDocument, TDestination>::value,
bool>::type
copyArray(T* src, size_t len, const TDestination& dst) {
bool ok = true;
for (size_t i = 0; i < len; i++) {
ok &= dst.add(src[i]);
}
return ok;
}
// Copy a 1D array to a JsonDocument
template <typename T>
inline bool copyArray(T* src, size_t len, JsonDocument& dst) {
return copyArray(src, len, dst.to<ArrayRef>());
}
// Copy a 2D array to a JsonArray
template <typename T, size_t N1, size_t N2, typename TDestination>
inline typename enable_if<!is_base_of<JsonDocument, TDestination>::value,
bool>::type
copyArray(T (&src)[N1][N2], const TDestination& dst) {
bool ok = true;
for (size_t i = 0; i < N1; i++) {
ArrayRef nestedArray = dst.createNestedArray();
for (size_t j = 0; j < N2; j++) {
ok &= nestedArray.add(src[i][j]);
}
}
return ok;
}
// Copy a 2D array to a JsonDocument
template <typename T, size_t N1, size_t N2>
inline bool copyArray(T (&src)[N1][N2], JsonDocument& dst) {
return copyArray(src, dst.to<ArrayRef>());
}
template <typename T>
class ArrayCopier1D {
public:
ArrayCopier1D(T* destination, size_t capacity)
: _destination(destination), _capacity(capacity), _size(0) {}
void visitArray(const CollectionData& array) {
VariantSlot* slot = array.head();
while (slot != 0 && _size < _capacity) {
_destination[_size++] = variantAs<T>(slot->data());
slot = slot->next();
}
}
void visitObject(const CollectionData&) {}
void visitFloat(Float) {}
void visitString(const char*) {}
void visitRawJson(const char*, size_t) {}
void visitNegativeInteger(UInt) {}
void visitPositiveInteger(UInt) {}
void visitBoolean(bool) {}
void visitNull() {}
size_t result() const {
return _size;
}
private:
T* _destination;
size_t _capacity;
size_t _size;
};
template <typename T, size_t N1, size_t N2>
class ArrayCopier2D {
public:
ArrayCopier2D(T (*destination)[N1][N2]) : _destination(destination) {}
void visitArray(const CollectionData& array) {
VariantSlot* slot = array.head();
size_t n = 0;
while (slot != 0 && n < N1) {
ArrayCopier1D<T> copier((*_destination)[n++], N2);
variantAccept(slot->data(), copier);
slot = slot->next();
}
}
void visitObject(const CollectionData&) {}
void visitFloat(Float) {}
void visitString(const char*) {}
void visitRawJson(const char*, size_t) {}
void visitNegativeInteger(UInt) {}
void visitPositiveInteger(UInt) {}
void visitBoolean(bool) {}
void visitNull() {}
private:
T (*_destination)[N1][N2];
size_t _capacity1, _capacity2;
};
// Copy a JsonArray to a 1D array
template <typename TSource, typename T, size_t N>
inline typename enable_if<!is_array<T>::value, size_t>::type copyArray(
const TSource& src, T (&dst)[N]) {
return copyArray(src, dst, N);
}
// Copy a JsonArray to a 1D array
template <typename TSource, typename T>
inline size_t copyArray(const TSource& src, T* dst, size_t len) {
ArrayCopier1D<T> copier(dst, len);
src.accept(copier);
return copier.result();
}
// Copy a JsonArray to a 2D array
template <typename TSource, typename T, size_t N1, size_t N2>
inline void copyArray(const TSource& src, T (&dst)[N1][N2]) {
ArrayCopier2D<T, N1, N2> copier(&dst);
src.accept(copier);
}
} // namespace ARDUINOJSON_NAMESPACE

176
lib_standalone/ArduinoJson/src/ArduinoJson/Collection/CollectionData.hpp → lib/ArduinoJson/src/ArduinoJson/Collection/CollectionData.hpp
View File

@@ -1,88 +1,88 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
#include <ArduinoJson/Polyfills/assert.hpp> #include <ArduinoJson/Polyfills/assert.hpp>
#include <stddef.h> // size_t #include <stddef.h> // size_t
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
class MemoryPool; class MemoryPool;
class VariantData; class VariantData;
class VariantSlot; class VariantSlot;
class CollectionData { class CollectionData {
VariantSlot *_head; VariantSlot *_head;
VariantSlot *_tail; VariantSlot *_tail;
public: public:
// Must be a POD! // Must be a POD!
// - no constructor // - no constructor
// - no destructor // - no destructor
// - no virtual // - no virtual
// - no inheritance // - no inheritance
// Array only // Array only
VariantData *addElement(MemoryPool *pool); VariantData *addElement(MemoryPool *pool);
VariantData *getElement(size_t index) const; VariantData *getElement(size_t index) const;
VariantData *getOrAddElement(size_t index, MemoryPool *pool); VariantData *getOrAddElement(size_t index, MemoryPool *pool);
void removeElement(size_t index); void removeElement(size_t index);
bool equalsArray(const CollectionData &other) const; bool equalsArray(const CollectionData &other) const;
// Object only // Object only
template <typename TAdaptedString> template <typename TAdaptedString>
VariantData *addMember(TAdaptedString key, MemoryPool *pool); VariantData *addMember(TAdaptedString key, MemoryPool *pool);
template <typename TAdaptedString> template <typename TAdaptedString>
VariantData *getMember(TAdaptedString key) const; VariantData *getMember(TAdaptedString key) const;
template <typename TAdaptedString> template <typename TAdaptedString>
VariantData *getOrAddMember(TAdaptedString key, MemoryPool *pool); VariantData *getOrAddMember(TAdaptedString key, MemoryPool *pool);
template <typename TAdaptedString> template <typename TAdaptedString>
void removeMember(TAdaptedString key) { void removeMember(TAdaptedString key) {
removeSlot(getSlot(key)); removeSlot(getSlot(key));
} }
template <typename TAdaptedString> template <typename TAdaptedString>
bool containsKey(const TAdaptedString &key) const; bool containsKey(const TAdaptedString &key) const;
bool equalsObject(const CollectionData &other) const; bool equalsObject(const CollectionData &other) const;
// Generic // Generic
void clear(); void clear();
size_t memoryUsage() const; size_t memoryUsage() const;
size_t nesting() const; size_t nesting() const;
size_t size() const; size_t size() const;
VariantSlot *addSlot(MemoryPool *); VariantSlot *addSlot(MemoryPool *);
void removeSlot(VariantSlot *slot); void removeSlot(VariantSlot *slot);
bool copyFrom(const CollectionData &src, MemoryPool *pool); bool copyFrom(const CollectionData &src, MemoryPool *pool);
VariantSlot *head() const { VariantSlot *head() const {
return _head; return _head;
} }
void movePointers(ptrdiff_t stringDistance, ptrdiff_t variantDistance); void movePointers(ptrdiff_t stringDistance, ptrdiff_t variantDistance);
private: private:
VariantSlot *getSlot(size_t index) const; VariantSlot *getSlot(size_t index) const;
template <typename TAdaptedString> template <typename TAdaptedString>
VariantSlot *getSlot(TAdaptedString key) const; VariantSlot *getSlot(TAdaptedString key) const;
VariantSlot *getPreviousSlot(VariantSlot *) const; VariantSlot *getPreviousSlot(VariantSlot *) const;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

460
lib_standalone/ArduinoJson/src/ArduinoJson/Collection/CollectionImpl.hpp → lib/ArduinoJson/src/ArduinoJson/Collection/CollectionImpl.hpp
View File

@@ -1,228 +1,232 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Collection/CollectionData.hpp> #include <ArduinoJson/Collection/CollectionData.hpp>
#include <ArduinoJson/Variant/VariantData.hpp> #include <ArduinoJson/Variant/VariantData.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
inline VariantSlot* CollectionData::addSlot(MemoryPool* pool) { inline bool variantEquals(const VariantData* a, const VariantData* b) {
VariantSlot* slot = pool->allocVariant(); return variantCompare(a, b) == COMPARE_RESULT_EQUAL;
if (!slot) }
return 0;
inline VariantSlot* CollectionData::addSlot(MemoryPool* pool) {
if (_tail) { VariantSlot* slot = pool->allocVariant();
_tail->setNextNotNull(slot); if (!slot)
_tail = slot; return 0;
} else {
_head = slot; if (_tail) {
_tail = slot; _tail->setNextNotNull(slot);
} _tail = slot;
} else {
slot->clear(); _head = slot;
return slot; _tail = slot;
} }
inline VariantData* CollectionData::addElement(MemoryPool* pool) { slot->clear();
return slotData(addSlot(pool)); return slot;
} }
template <typename TAdaptedString> inline VariantData* CollectionData::addElement(MemoryPool* pool) {
inline VariantData* CollectionData::addMember(TAdaptedString key, return slotData(addSlot(pool));
MemoryPool* pool) { }
VariantSlot* slot = addSlot(pool);
if (!slotSetKey(slot, key, pool)) { template <typename TAdaptedString>
removeSlot(slot); inline VariantData* CollectionData::addMember(TAdaptedString key,
return 0; MemoryPool* pool) {
} VariantSlot* slot = addSlot(pool);
return slot->data(); if (!slotSetKey(slot, key, pool)) {
} removeSlot(slot);
return 0;
inline void CollectionData::clear() { }
_head = 0; return slot->data();
_tail = 0; }
}
inline void CollectionData::clear() {
template <typename TAdaptedString> _head = 0;
inline bool CollectionData::containsKey(const TAdaptedString& key) const { _tail = 0;
return getSlot(key) != 0; }
}
template <typename TAdaptedString>
inline bool CollectionData::copyFrom(const CollectionData& src, inline bool CollectionData::containsKey(const TAdaptedString& key) const {
MemoryPool* pool) { return getSlot(key) != 0;
clear(); }
for (VariantSlot* s = src._head; s; s = s->next()) {
VariantData* var; inline bool CollectionData::copyFrom(const CollectionData& src,
if (s->key() != 0) { MemoryPool* pool) {
if (s->ownsKey()) clear();
var = addMember(RamStringAdapter(s->key()), pool); for (VariantSlot* s = src._head; s; s = s->next()) {
else VariantData* var;
var = addMember(ConstRamStringAdapter(s->key()), pool); if (s->key() != 0) {
} else { if (s->ownsKey())
var = addElement(pool); var = addMember(RamStringAdapter(s->key()), pool);
} else
if (!var) var = addMember(ConstRamStringAdapter(s->key()), pool);
return false; } else {
if (!var->copyFrom(*s->data(), pool)) var = addElement(pool);
return false; }
} if (!var)
return true; return false;
} if (!var->copyFrom(*s->data(), pool))
return false;
inline bool CollectionData::equalsObject(const CollectionData& other) const { }
size_t count = 0; return true;
for (VariantSlot* slot = _head; slot; slot = slot->next()) { }
VariantData* v1 = slot->data();
VariantData* v2 = other.getMember(adaptString(slot->key())); inline bool CollectionData::equalsObject(const CollectionData& other) const {
if (!variantEquals(v1, v2)) size_t count = 0;
return false; for (VariantSlot* slot = _head; slot; slot = slot->next()) {
count++; VariantData* v1 = slot->data();
} VariantData* v2 = other.getMember(adaptString(slot->key()));
return count == other.size(); if (!variantEquals(v1, v2))
} return false;
count++;
inline bool CollectionData::equalsArray(const CollectionData& other) const { }
VariantSlot* s1 = _head; return count == other.size();
VariantSlot* s2 = other._head; }
for (;;) {
if (s1 == s2) inline bool CollectionData::equalsArray(const CollectionData& other) const {
return true; VariantSlot* s1 = _head;
if (!s1 || !s2) VariantSlot* s2 = other._head;
return false; for (;;) {
if (!variantEquals(s1->data(), s2->data())) if (s1 == s2)
return false; return true;
s1 = s1->next(); if (!s1 || !s2)
s2 = s2->next(); return false;
} if (!variantEquals(s1->data(), s2->data()))
} return false;
s1 = s1->next();
template <typename TAdaptedString> s2 = s2->next();
inline VariantSlot* CollectionData::getSlot(TAdaptedString key) const { }
VariantSlot* slot = _head; }
while (slot) {
if (key.equals(slot->key())) template <typename TAdaptedString>
break; inline VariantSlot* CollectionData::getSlot(TAdaptedString key) const {
slot = slot->next(); VariantSlot* slot = _head;
} while (slot) {
return slot; if (key.equals(slot->key()))
} break;
slot = slot->next();
inline VariantSlot* CollectionData::getSlot(size_t index) const { }
return _head->next(index); return slot;
} }
inline VariantSlot* CollectionData::getPreviousSlot(VariantSlot* target) const { inline VariantSlot* CollectionData::getSlot(size_t index) const {
VariantSlot* current = _head; return _head->next(index);
while (current) { }
VariantSlot* next = current->next();
if (next == target) inline VariantSlot* CollectionData::getPreviousSlot(VariantSlot* target) const {
return current; VariantSlot* current = _head;
current = next; while (current) {
} VariantSlot* next = current->next();
return 0; if (next == target)
} return current;
current = next;
template <typename TAdaptedString> }
inline VariantData* CollectionData::getMember(TAdaptedString key) const { return 0;
VariantSlot* slot = getSlot(key); }
return slot ? slot->data() : 0;
} template <typename TAdaptedString>
inline VariantData* CollectionData::getMember(TAdaptedString key) const {
template <typename TAdaptedString> VariantSlot* slot = getSlot(key);
inline VariantData* CollectionData::getOrAddMember(TAdaptedString key, return slot ? slot->data() : 0;
MemoryPool* pool) { }
// ignore null key
if (key.isNull()) template <typename TAdaptedString>
return 0; inline VariantData* CollectionData::getOrAddMember(TAdaptedString key,
MemoryPool* pool) {
// search a matching key // ignore null key
VariantSlot* slot = getSlot(key); if (key.isNull())
if (slot) return 0;
return slot->data();
// search a matching key
return addMember(key, pool); VariantSlot* slot = getSlot(key);
} if (slot)
return slot->data();
inline VariantData* CollectionData::getElement(size_t index) const {
VariantSlot* slot = getSlot(index); return addMember(key, pool);
return slot ? slot->data() : 0; }
}
inline VariantData* CollectionData::getElement(size_t index) const {
inline VariantData* CollectionData::getOrAddElement(size_t index, VariantSlot* slot = getSlot(index);
MemoryPool* pool) { return slot ? slot->data() : 0;
VariantSlot* slot = _head; }
while (slot && index > 0) {
slot = slot->next(); inline VariantData* CollectionData::getOrAddElement(size_t index,
index--; MemoryPool* pool) {
} VariantSlot* slot = _head;
if (!slot) while (slot && index > 0) {
index++; slot = slot->next();
while (index > 0) { index--;
slot = addSlot(pool); }
index--; if (!slot)
} index++;
return slotData(slot); while (index > 0) {
} slot = addSlot(pool);
index--;
inline void CollectionData::removeSlot(VariantSlot* slot) { }
if (!slot) return slotData(slot);
return; }
VariantSlot* prev = getPreviousSlot(slot);
VariantSlot* next = slot->next(); inline void CollectionData::removeSlot(VariantSlot* slot) {
if (prev) if (!slot)
prev->setNext(next); return;
else VariantSlot* prev = getPreviousSlot(slot);
_head = next; VariantSlot* next = slot->next();
if (!next) if (prev)
_tail = prev; prev->setNext(next);
} else
_head = next;
inline void CollectionData::removeElement(size_t index) { if (!next)
removeSlot(getSlot(index)); _tail = prev;
} }
inline size_t CollectionData::memoryUsage() const { inline void CollectionData::removeElement(size_t index) {
size_t total = 0; removeSlot(getSlot(index));
for (VariantSlot* s = _head; s; s = s->next()) { }
total += sizeof(VariantSlot) + s->data()->memoryUsage();
if (s->ownsKey()) inline size_t CollectionData::memoryUsage() const {
total += strlen(s->key()) + 1; size_t total = 0;
} for (VariantSlot* s = _head; s; s = s->next()) {
return total; total += sizeof(VariantSlot) + s->data()->memoryUsage();
} if (s->ownsKey())
total += strlen(s->key()) + 1;
inline size_t CollectionData::nesting() const { }
size_t maxChildNesting = 0; return total;
for (VariantSlot* s = _head; s; s = s->next()) { }
size_t childNesting = s->data()->nesting();
if (childNesting > maxChildNesting) inline size_t CollectionData::nesting() const {
maxChildNesting = childNesting; size_t maxChildNesting = 0;
} for (VariantSlot* s = _head; s; s = s->next()) {
return maxChildNesting + 1; size_t childNesting = s->data()->nesting();
} if (childNesting > maxChildNesting)
maxChildNesting = childNesting;
inline size_t CollectionData::size() const { }
return slotSize(_head); return maxChildNesting + 1;
} }
template <typename T> inline size_t CollectionData::size() const {
inline void movePointer(T*& p, ptrdiff_t offset) { return slotSize(_head);
if (!p) }
return;
p = reinterpret_cast<T*>( template <typename T>
reinterpret_cast<void*>(reinterpret_cast<char*>(p) + offset)); inline void movePointer(T*& p, ptrdiff_t offset) {
ARDUINOJSON_ASSERT(isAligned(p)); if (!p)
} return;
p = reinterpret_cast<T*>(
inline void CollectionData::movePointers(ptrdiff_t stringDistance, reinterpret_cast<void*>(reinterpret_cast<char*>(p) + offset));
ptrdiff_t variantDistance) { ARDUINOJSON_ASSERT(isAligned(p));
movePointer(_head, variantDistance); }
movePointer(_tail, variantDistance);
for (VariantSlot* slot = _head; slot; slot = slot->next()) inline void CollectionData::movePointers(ptrdiff_t stringDistance,
slot->movePointers(stringDistance, variantDistance); ptrdiff_t variantDistance) {
} movePointer(_head, variantDistance);
movePointer(_tail, variantDistance);
} // namespace ARDUINOJSON_NAMESPACE for (VariantSlot* slot = _head; slot; slot = slot->next())
slot->movePointers(stringDistance, variantDistance);
}
} // namespace ARDUINOJSON_NAMESPACE

452
lib_standalone/ArduinoJson/src/ArduinoJson/Configuration.hpp → lib/ArduinoJson/src/ArduinoJson/Configuration.hpp
View File

@@ -1,220 +1,232 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#if defined(_MSC_VER) #if __cplusplus >= 201103L
#define ARDUINOJSON_HAS_INT64 1 #define ARDUINOJSON_HAS_LONG_LONG 1
#else #define ARDUINOJSON_HAS_NULLPTR 1
#define ARDUINOJSON_HAS_INT64 0 #define ARDUINOJSON_HAS_RVALUE_REFERENCES 1
#endif #else
#define ARDUINOJSON_HAS_LONG_LONG 0
#if __cplusplus >= 201103L #define ARDUINOJSON_HAS_NULLPTR 0
#define ARDUINOJSON_HAS_LONG_LONG 1 #define ARDUINOJSON_HAS_RVALUE_REFERENCES 0
#define ARDUINOJSON_HAS_NULLPTR 1 #endif
#define ARDUINOJSON_HAS_RVALUE_REFERENCES 1
#else #if defined(_MSC_VER) && !ARDUINOJSON_HAS_LONG_LONG
#define ARDUINOJSON_HAS_LONG_LONG 0 #define ARDUINOJSON_HAS_INT64 1
#define ARDUINOJSON_HAS_NULLPTR 0 #else
#define ARDUINOJSON_HAS_RVALUE_REFERENCES 0 #define ARDUINOJSON_HAS_INT64 0
#endif #endif
// Small or big machine? // Small or big machine?
#ifndef ARDUINOJSON_EMBEDDED_MODE #ifndef ARDUINOJSON_EMBEDDED_MODE
#if defined(ARDUINO) /* Arduino*/ \ #if defined(ARDUINO) /* Arduino*/ \
|| defined(__IAR_SYSTEMS_ICC__) /* IAR Embedded Workbench */ \ || defined(__IAR_SYSTEMS_ICC__) /* IAR Embedded Workbench */ \
|| defined(__XC) /* MPLAB XC compiler */ \ || defined(__XC) /* MPLAB XC compiler */ \
|| defined(__ARMCC_VERSION) /* Keil ARM Compiler */ \ || defined(__ARMCC_VERSION) /* Keil ARM Compiler */ \
|| defined(__AVR) /* Atmel AVR8/GNU C Compiler */ || defined(__AVR) /* Atmel AVR8/GNU C Compiler */
#define ARDUINOJSON_EMBEDDED_MODE 1 #define ARDUINOJSON_EMBEDDED_MODE 1
#else #else
#define ARDUINOJSON_EMBEDDED_MODE 0 #define ARDUINOJSON_EMBEDDED_MODE 0
#endif #endif
#endif #endif
// Auto enable std::stream if the right headers are here and no conflicting // Auto enable std::stream if the right headers are here and no conflicting
// macro is defined // macro is defined
#if !defined(ARDUINOJSON_ENABLE_STD_STREAM) && defined(__has_include) #if !defined(ARDUINOJSON_ENABLE_STD_STREAM) && defined(__has_include)
#if __has_include(<istream>) && \ #if __has_include(<istream>) && \
__has_include(<ostream>) && \ __has_include(<ostream>) && \
!defined(min) && \ !defined(min) && \
!defined(max) !defined(max)
#define ARDUINOJSON_ENABLE_STD_STREAM 1 #define ARDUINOJSON_ENABLE_STD_STREAM 1
#else #else
#define ARDUINOJSON_ENABLE_STD_STREAM 0 #define ARDUINOJSON_ENABLE_STD_STREAM 0
#endif #endif
#endif #endif
// Auto enable std::string if the right header is here and no conflicting // Auto enable std::string if the right header is here and no conflicting
// macro is defined // macro is defined
#if !defined(ARDUINOJSON_ENABLE_STD_STRING) && defined(__has_include) #if !defined(ARDUINOJSON_ENABLE_STD_STRING) && defined(__has_include)
#if __has_include(<string>) && !defined(min) && !defined(max) #if __has_include(<string>) && !defined(min) && !defined(max)
#define ARDUINOJSON_ENABLE_STD_STRING 1 #define ARDUINOJSON_ENABLE_STD_STRING 1
#else #else
#define ARDUINOJSON_ENABLE_STD_STRING 0 #define ARDUINOJSON_ENABLE_STD_STRING 0
#endif #endif
#endif #endif
#if ARDUINOJSON_EMBEDDED_MODE #if ARDUINOJSON_EMBEDDED_MODE
// Store floats by default to reduce the memory usage (issue #134) // Store floats by default to reduce the memory usage (issue #134)
#ifndef ARDUINOJSON_USE_DOUBLE #ifndef ARDUINOJSON_USE_DOUBLE
#define ARDUINOJSON_USE_DOUBLE 0 #define ARDUINOJSON_USE_DOUBLE 0
#endif #endif
// Store longs by default, because they usually match the size of a float. // Store longs by default, because they usually match the size of a float.
#ifndef ARDUINOJSON_USE_LONG_LONG #ifndef ARDUINOJSON_USE_LONG_LONG
#define ARDUINOJSON_USE_LONG_LONG 0 #define ARDUINOJSON_USE_LONG_LONG 0
#endif #endif
// Embedded systems usually don't have std::string // Embedded systems usually don't have std::string
#ifndef ARDUINOJSON_ENABLE_STD_STRING #ifndef ARDUINOJSON_ENABLE_STD_STRING
#define ARDUINOJSON_ENABLE_STD_STRING 0 #define ARDUINOJSON_ENABLE_STD_STRING 0
#endif #endif
// Embedded systems usually don't have std::stream // Embedded systems usually don't have std::stream
#ifndef ARDUINOJSON_ENABLE_STD_STREAM #ifndef ARDUINOJSON_ENABLE_STD_STREAM
#define ARDUINOJSON_ENABLE_STD_STREAM 0 #define ARDUINOJSON_ENABLE_STD_STREAM 0
#endif #endif
// Limit nesting as the stack is likely to be small // Limit nesting as the stack is likely to be small
#ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT #ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
#define ARDUINOJSON_DEFAULT_NESTING_LIMIT 10 #define ARDUINOJSON_DEFAULT_NESTING_LIMIT 10
#endif #endif
#else // ARDUINOJSON_EMBEDDED_MODE #else // ARDUINOJSON_EMBEDDED_MODE
// On a computer we have plenty of memory so we can use doubles // On a computer we have plenty of memory so we can use doubles
#ifndef ARDUINOJSON_USE_DOUBLE #ifndef ARDUINOJSON_USE_DOUBLE
#define ARDUINOJSON_USE_DOUBLE 1 #define ARDUINOJSON_USE_DOUBLE 1
#endif #endif
// Use long long when available // Use long long when available
#ifndef ARDUINOJSON_USE_LONG_LONG #ifndef ARDUINOJSON_USE_LONG_LONG
#if ARDUINOJSON_HAS_LONG_LONG || ARDUINOJSON_HAS_INT64 #if ARDUINOJSON_HAS_LONG_LONG || ARDUINOJSON_HAS_INT64
#define ARDUINOJSON_USE_LONG_LONG 1 #define ARDUINOJSON_USE_LONG_LONG 1
#else #else
#define ARDUINOJSON_USE_LONG_LONG 0 #define ARDUINOJSON_USE_LONG_LONG 0
#endif #endif
#endif #endif
// On a computer, we can use std::string // On a computer, we can use std::string
#ifndef ARDUINOJSON_ENABLE_STD_STRING #ifndef ARDUINOJSON_ENABLE_STD_STRING
#define ARDUINOJSON_ENABLE_STD_STRING 1 #define ARDUINOJSON_ENABLE_STD_STRING 1
#endif #endif
// On a computer, we can assume std::stream // On a computer, we can assume std::stream
#ifndef ARDUINOJSON_ENABLE_STD_STREAM #ifndef ARDUINOJSON_ENABLE_STD_STREAM
#define ARDUINOJSON_ENABLE_STD_STREAM 1 #define ARDUINOJSON_ENABLE_STD_STREAM 1
#endif #endif
// On a computer, the stack is large so we can increase nesting limit // On a computer, the stack is large so we can increase nesting limit
#ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT #ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
#define ARDUINOJSON_DEFAULT_NESTING_LIMIT 50 #define ARDUINOJSON_DEFAULT_NESTING_LIMIT 50
#endif #endif
#endif // ARDUINOJSON_EMBEDDED_MODE #endif // ARDUINOJSON_EMBEDDED_MODE
#ifdef ARDUINO #ifdef ARDUINO
#include <Arduino.h> #include <Arduino.h>
// Enable support for Arduino's String class // Enable support for Arduino's String class
#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING #ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1 #define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
#endif #endif
// Enable support for Arduino's Stream class // Enable support for Arduino's Stream class
#ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM #ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1 #define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1
#endif #endif
// Enable support for Arduino's Print class // Enable support for Arduino's Print class
#ifndef ARDUINOJSON_ENABLE_ARDUINO_PRINT #ifndef ARDUINOJSON_ENABLE_ARDUINO_PRINT
#define ARDUINOJSON_ENABLE_ARDUINO_PRINT 1 #define ARDUINOJSON_ENABLE_ARDUINO_PRINT 1
#endif #endif
#else // ARDUINO #else // ARDUINO
// Disable support for Arduino's String class // Disable support for Arduino's String class
#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING #ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
#define ARDUINOJSON_ENABLE_ARDUINO_STRING 0 #define ARDUINOJSON_ENABLE_ARDUINO_STRING 0
#endif #endif
// Disable support for Arduino's Stream class // Disable support for Arduino's Stream class
#ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM #ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 0 #define ARDUINOJSON_ENABLE_ARDUINO_STREAM 0
#endif #endif
// Disable support for Arduino's Print class // Disable support for Arduino's Print class
#ifndef ARDUINOJSON_ENABLE_ARDUINO_PRINT #ifndef ARDUINOJSON_ENABLE_ARDUINO_PRINT
#define ARDUINOJSON_ENABLE_ARDUINO_PRINT 0 #define ARDUINOJSON_ENABLE_ARDUINO_PRINT 0
#endif #endif
#endif // ARDUINO #endif // ARDUINO
#ifndef ARDUINOJSON_ENABLE_PROGMEM #ifndef ARDUINOJSON_ENABLE_PROGMEM
#ifdef PROGMEM #ifdef PROGMEM
#define ARDUINOJSON_ENABLE_PROGMEM 1 #define ARDUINOJSON_ENABLE_PROGMEM 1
#else #else
#define ARDUINOJSON_ENABLE_PROGMEM 0 #define ARDUINOJSON_ENABLE_PROGMEM 0
#endif #endif
#endif #endif
// Convert unicode escape sequence (\u0123) to UTF-8 // Convert unicode escape sequence (\u0123) to UTF-8
#ifndef ARDUINOJSON_DECODE_UNICODE #ifndef ARDUINOJSON_DECODE_UNICODE
#define ARDUINOJSON_DECODE_UNICODE 0 #define ARDUINOJSON_DECODE_UNICODE 1
#endif #endif
// Ignore comments in input // Ignore comments in input
#ifndef ARDUINOJSON_ENABLE_COMMENTS #ifndef ARDUINOJSON_ENABLE_COMMENTS
#define ARDUINOJSON_ENABLE_COMMENTS 0 #define ARDUINOJSON_ENABLE_COMMENTS 0
#endif #endif
// Support NaN in JSON // Support NaN in JSON
#ifndef ARDUINOJSON_ENABLE_NAN #ifndef ARDUINOJSON_ENABLE_NAN
#define ARDUINOJSON_ENABLE_NAN 0 #define ARDUINOJSON_ENABLE_NAN 0
#endif #endif
// Support Infinity in JSON // Support Infinity in JSON
#ifndef ARDUINOJSON_ENABLE_INFINITY #ifndef ARDUINOJSON_ENABLE_INFINITY
#define ARDUINOJSON_ENABLE_INFINITY 0 #define ARDUINOJSON_ENABLE_INFINITY 0
#endif #endif
// Control the exponentiation threshold for big numbers // Control the exponentiation threshold for big numbers
// CAUTION: cannot be more that 1e9 !!!! // CAUTION: cannot be more that 1e9 !!!!
#ifndef ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD #ifndef ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD
#define ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD 1e7 #define ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD 1e7
#endif #endif
// Control the exponentiation threshold for small numbers // Control the exponentiation threshold for small numbers
#ifndef ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD #ifndef ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD
#define ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD 1e-5 #define ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD 1e-5
#endif #endif
#ifndef ARDUINOJSON_LITTLE_ENDIAN #ifndef ARDUINOJSON_LITTLE_ENDIAN
#if defined(_MSC_VER) || \ #if defined(_MSC_VER) || \
(defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || \ (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || \
defined(__LITTLE_ENDIAN__) || defined(__i386) || defined(__x86_64) defined(__LITTLE_ENDIAN__) || defined(__i386) || defined(__x86_64)
#define ARDUINOJSON_LITTLE_ENDIAN 1 #define ARDUINOJSON_LITTLE_ENDIAN 1
#else #else
#define ARDUINOJSON_LITTLE_ENDIAN 0 #define ARDUINOJSON_LITTLE_ENDIAN 0
#endif #endif
#endif #endif
#ifndef ARDUINOJSON_TAB #ifndef ARDUINOJSON_ENABLE_ALIGNMENT
#define ARDUINOJSON_TAB " " #if defined(__AVR)
#endif #define ARDUINOJSON_ENABLE_ALIGNMENT 0
#else
#ifndef ARDUINOJSON_STRING_BUFFER_SIZE #define ARDUINOJSON_ENABLE_ALIGNMENT 1
#define ARDUINOJSON_STRING_BUFFER_SIZE 32 #endif
#endif #endif
#ifndef ARDUINOJSON_DEBUG #ifndef ARDUINOJSON_TAB
#ifdef __PLATFORMIO_BUILD_DEBUG__ #define ARDUINOJSON_TAB " "
#define ARDUINOJSON_DEBUG 1 #endif
#else
#define ARDUINOJSON_DEBUG 0 #ifndef ARDUINOJSON_ENABLE_STRING_DEDUPLICATION
#endif #define ARDUINOJSON_ENABLE_STRING_DEDUPLICATION 1
#endif #endif
#ifndef ARDUINOJSON_STRING_BUFFER_SIZE
#define ARDUINOJSON_STRING_BUFFER_SIZE 32
#endif
#ifndef ARDUINOJSON_DEBUG
#ifdef __PLATFORMIO_BUILD_DEBUG__
#define ARDUINOJSON_DEBUG 1
#else
#define ARDUINOJSON_DEBUG 0
#endif
#endif

230
lib_standalone/ArduinoJson/src/ArduinoJson/Deserialization/DeserializationError.hpp → lib/ArduinoJson/src/ArduinoJson/Deserialization/DeserializationError.hpp
View File

@@ -1,115 +1,115 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
#if ARDUINOJSON_ENABLE_STD_STREAM #if ARDUINOJSON_ENABLE_STD_STREAM
#include <ostream> #include <ostream>
#endif #endif
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
class DeserializationError { class DeserializationError {
// safe bool idiom // safe bool idiom
typedef void (DeserializationError::*bool_type)() const; typedef void (DeserializationError::*bool_type)() const;
void safeBoolHelper() const {} void safeBoolHelper() const {}
public: public:
enum Code { enum Code {
Ok, Ok,
IncompleteInput, IncompleteInput,
InvalidInput, InvalidInput,
NoMemory, NoMemory,
NotSupported, NotSupported,
TooDeep TooDeep
}; };
DeserializationError() {} DeserializationError() {}
DeserializationError(Code c) : _code(c) {} DeserializationError(Code c) : _code(c) {}
// Compare with DeserializationError // Compare with DeserializationError
friend bool operator==(const DeserializationError& lhs, friend bool operator==(const DeserializationError& lhs,
const DeserializationError& rhs) { const DeserializationError& rhs) {
return lhs._code == rhs._code; return lhs._code == rhs._code;
} }
friend bool operator!=(const DeserializationError& lhs, friend bool operator!=(const DeserializationError& lhs,
const DeserializationError& rhs) { const DeserializationError& rhs) {
return lhs._code != rhs._code; return lhs._code != rhs._code;
} }
// Compare with Code // Compare with Code
friend bool operator==(const DeserializationError& lhs, Code rhs) { friend bool operator==(const DeserializationError& lhs, Code rhs) {
return lhs._code == rhs; return lhs._code == rhs;
} }
friend bool operator==(Code lhs, const DeserializationError& rhs) { friend bool operator==(Code lhs, const DeserializationError& rhs) {
return lhs == rhs._code; return lhs == rhs._code;
} }
friend bool operator!=(const DeserializationError& lhs, Code rhs) { friend bool operator!=(const DeserializationError& lhs, Code rhs) {
return lhs._code != rhs; return lhs._code != rhs;
} }
friend bool operator!=(Code lhs, const DeserializationError& rhs) { friend bool operator!=(Code lhs, const DeserializationError& rhs) {
return lhs != rhs._code; return lhs != rhs._code;
} }
// Behaves like a bool // Behaves like a bool
operator bool_type() const { operator bool_type() const {
return _code != Ok ? &DeserializationError::safeBoolHelper : 0; return _code != Ok ? &DeserializationError::safeBoolHelper : 0;
} }
friend bool operator==(bool value, const DeserializationError& err) { friend bool operator==(bool value, const DeserializationError& err) {
return static_cast<bool>(err) == value; return static_cast<bool>(err) == value;
} }
friend bool operator==(const DeserializationError& err, bool value) { friend bool operator==(const DeserializationError& err, bool value) {
return static_cast<bool>(err) == value; return static_cast<bool>(err) == value;
} }
friend bool operator!=(bool value, const DeserializationError& err) { friend bool operator!=(bool value, const DeserializationError& err) {
return static_cast<bool>(err) != value; return static_cast<bool>(err) != value;
} }
friend bool operator!=(const DeserializationError& err, bool value) { friend bool operator!=(const DeserializationError& err, bool value) {
return static_cast<bool>(err) != value; return static_cast<bool>(err) != value;
} }
// Returns internal enum, useful for switch statement // Returns internal enum, useful for switch statement
Code code() const { Code code() const {
return _code; return _code;
} }
const char* c_str() const { const char* c_str() const {
switch (_code) { switch (_code) {
case Ok: case Ok:
return "Ok"; return "Ok";
case TooDeep: case TooDeep:
return "TooDeep"; return "TooDeep";
case NoMemory: case NoMemory:
return "NoMemory"; return "NoMemory";
case InvalidInput: case InvalidInput:
return "InvalidInput"; return "InvalidInput";
case IncompleteInput: case IncompleteInput:
return "IncompleteInput"; return "IncompleteInput";
case NotSupported: case NotSupported:
return "NotSupported"; return "NotSupported";
default: default:
return "???"; return "???";
} }
} }
private: private:
Code _code; Code _code;
}; };
#if ARDUINOJSON_ENABLE_STD_STREAM #if ARDUINOJSON_ENABLE_STD_STREAM
inline std::ostream& operator<<(std::ostream& s, inline std::ostream& operator<<(std::ostream& s,
const DeserializationError& e) { const DeserializationError& e) {
s << e.c_str(); s << e.c_str();
return s; return s;
} }
inline std::ostream& operator<<(std::ostream& s, DeserializationError::Code c) { inline std::ostream& operator<<(std::ostream& s, DeserializationError::Code c) {
s << DeserializationError(c).c_str(); s << DeserializationError(c).c_str();
return s; return s;
} }
#endif #endif
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

132
lib_standalone/ArduinoJson/src/ArduinoJson/Deserialization/Filter.hpp → lib/ArduinoJson/src/ArduinoJson/Deserialization/Filter.hpp
View File

@@ -1,66 +1,66 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
class Filter { class Filter {
public: public:
explicit Filter(VariantConstRef v) : _variant(v) {} explicit Filter(VariantConstRef v) : _variant(v) {}
bool allow() const { bool allow() const {
return _variant; return _variant;
} }
bool allowArray() const { bool allowArray() const {
return _variant == true || _variant.is<ArrayRef>(); return _variant == true || _variant.is<ArrayRef>();
} }
bool allowObject() const { bool allowObject() const {
return _variant == true || _variant.is<ObjectRef>(); return _variant == true || _variant.is<ObjectRef>();
} }
bool allowValue() const { bool allowValue() const {
return _variant == true; return _variant == true;
} }
template <typename TKey> template <typename TKey>
Filter operator[](const TKey& key) const { Filter operator[](const TKey& key) const {
if (_variant == true) // "true" means "allow recursively" if (_variant == true) // "true" means "allow recursively"
return *this; return *this;
else else
return Filter(_variant[key]); return Filter(_variant[key]);
} }
private: private:
VariantConstRef _variant; VariantConstRef _variant;
}; };
struct AllowAllFilter { struct AllowAllFilter {
bool allow() const { bool allow() const {
return true; return true;
} }
bool allowArray() const { bool allowArray() const {
return true; return true;
} }
bool allowObject() const { bool allowObject() const {
return true; return true;
} }
bool allowValue() const { bool allowValue() const {
return true; return true;
} }
template <typename TKey> template <typename TKey>
AllowAllFilter operator[](const TKey&) const { AllowAllFilter operator[](const TKey&) const {
return AllowAllFilter(); return AllowAllFilter();
} }
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

58
lib_standalone/ArduinoJson/src/ArduinoJson/Deserialization/NestingLimit.hpp → lib/ArduinoJson/src/ArduinoJson/Deserialization/NestingLimit.hpp
View File

@@ -1,29 +1,29 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
#include <ArduinoJson/Polyfills/assert.hpp> #include <ArduinoJson/Polyfills/assert.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
class NestingLimit { class NestingLimit {
public: public:
NestingLimit() : _value(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {} NestingLimit() : _value(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {}
explicit NestingLimit(uint8_t n) : _value(n) {} explicit NestingLimit(uint8_t n) : _value(n) {}
NestingLimit decrement() const { NestingLimit decrement() const {
ARDUINOJSON_ASSERT(_value > 0); ARDUINOJSON_ASSERT(_value > 0);
return NestingLimit(static_cast<uint8_t>(_value - 1)); return NestingLimit(static_cast<uint8_t>(_value - 1));
} }
bool reached() const { bool reached() const {
return _value == 0; return _value == 0;
} }
private: private:
uint8_t _value; uint8_t _value;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

111
lib_standalone/ArduinoJson/src/ArduinoJson/Deserialization/Reader.hpp → lib/ArduinoJson/src/ArduinoJson/Deserialization/Reader.hpp
View File

@@ -1,55 +1,56 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
#include <stdlib.h> // for size_t #include <stdlib.h> // for size_t
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
// The default reader is a simple wrapper for Readers that are not copiable // The default reader is a simple wrapper for Readers that are not copiable
template <typename TSource, typename Enable = void> template <typename TSource, typename Enable = void>
struct Reader { struct Reader {
public: public:
Reader(TSource& source) : _source(&source) {} Reader(TSource& source) : _source(&source) {}
int read() { int read() {
return _source->read(); return _source->read();
} }
size_t readBytes(char* buffer, size_t length) { size_t readBytes(char* buffer, size_t length) {
return _source->readBytes(buffer, length); return _source->readBytes(buffer, length);
} }
private: private:
TSource* _source; TSource* _source;
}; };
template <typename TSource, typename Enable = void> template <typename TSource, typename Enable = void>
struct BoundedReader { struct BoundedReader {
// no default implementation because we need to pass the size to the // no default implementation because we need to pass the size to the
// constructor // constructor
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE
#include <ArduinoJson/Deserialization/Readers/IteratorReader.hpp> #include <ArduinoJson/Deserialization/Readers/IteratorReader.hpp>
#include <ArduinoJson/Deserialization/Readers/RamReader.hpp> #include <ArduinoJson/Deserialization/Readers/RamReader.hpp>
#include <ArduinoJson/Deserialization/Readers/VariantReader.hpp>
#if ARDUINOJSON_ENABLE_ARDUINO_STREAM
#include <ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp> #if ARDUINOJSON_ENABLE_ARDUINO_STREAM
#endif #include <ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp>
#endif
#if ARDUINOJSON_ENABLE_ARDUINO_STRING
#include <ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp> #if ARDUINOJSON_ENABLE_ARDUINO_STRING
#endif #include <ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp>
#endif
#if ARDUINOJSON_ENABLE_PROGMEM
#include <ArduinoJson/Deserialization/Readers/FlashReader.hpp> #if ARDUINOJSON_ENABLE_PROGMEM
#endif #include <ArduinoJson/Deserialization/Readers/FlashReader.hpp>
#endif
#if ARDUINOJSON_ENABLE_STD_STREAM
#include <ArduinoJson/Deserialization/Readers/StdStreamReader.hpp> #if ARDUINOJSON_ENABLE_STD_STREAM
#endif #include <ArduinoJson/Deserialization/Readers/StdStreamReader.hpp>
#endif

62
lib_standalone/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp → lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp
View File

@@ -1,31 +1,31 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <Stream.h> #include <Stream.h>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TSource> template <typename TSource>
struct Reader<TSource, struct Reader<TSource,
typename enable_if<is_base_of<Stream, TSource>::value>::type> { typename enable_if<is_base_of<Stream, TSource>::value>::type> {
public: public:
explicit Reader(Stream& stream) : _stream(&stream) {} explicit Reader(Stream& stream) : _stream(&stream) {}
int read() { int read() {
// don't use _stream.read() as it ignores the timeout // don't use _stream.read() as it ignores the timeout
char c; char c;
return _stream->readBytes(&c, 1) ? static_cast<unsigned char>(c) : -1; return _stream->readBytes(&c, 1) ? static_cast<unsigned char>(c) : -1;
} }
size_t readBytes(char* buffer, size_t length) { size_t readBytes(char* buffer, size_t length) {
return _stream->readBytes(buffer, length); return _stream->readBytes(buffer, length);
} }
private: private:
Stream* _stream; Stream* _stream;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

34
lib_standalone/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp → lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp
View File

@@ -1,17 +1,17 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TSource> template <typename TSource>
struct Reader<TSource, struct Reader<TSource,
typename enable_if<is_base_of< ::String, TSource>::value>::type> typename enable_if<is_base_of< ::String, TSource>::value>::type>
: BoundedReader<const char*> { : BoundedReader<const char*> {
explicit Reader(const ::String& s) explicit Reader(const ::String& s)
: BoundedReader<const char*>(s.c_str(), s.length()) {} : BoundedReader<const char*>(s.c_str(), s.length()) {}
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

106
lib_standalone/ArduinoJson/src/ArduinoJson/Deserialization/Readers/FlashReader.hpp → lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/FlashReader.hpp
View File

@@ -1,53 +1,53 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <> template <>
struct Reader<const __FlashStringHelper*, void> { struct Reader<const __FlashStringHelper*, void> {
const char* _ptr; const char* _ptr;
public: public:
explicit Reader(const __FlashStringHelper* ptr) explicit Reader(const __FlashStringHelper* ptr)
: _ptr(reinterpret_cast<const char*>(ptr)) {} : _ptr(reinterpret_cast<const char*>(ptr)) {}
int read() { int read() {
return pgm_read_byte(_ptr++); return pgm_read_byte(_ptr++);
} }
size_t readBytes(char* buffer, size_t length) { size_t readBytes(char* buffer, size_t length) {
memcpy_P(buffer, _ptr, length); memcpy_P(buffer, _ptr, length);
_ptr += length; _ptr += length;
return length; return length;
} }
}; };
template <> template <>
struct BoundedReader<const __FlashStringHelper*, void> { struct BoundedReader<const __FlashStringHelper*, void> {
const char* _ptr; const char* _ptr;
const char* _end; const char* _end;
public: public:
explicit BoundedReader(const __FlashStringHelper* ptr, size_t size) explicit BoundedReader(const __FlashStringHelper* ptr, size_t size)
: _ptr(reinterpret_cast<const char*>(ptr)), _end(_ptr + size) {} : _ptr(reinterpret_cast<const char*>(ptr)), _end(_ptr + size) {}
int read() { int read() {
if (_ptr < _end) if (_ptr < _end)
return pgm_read_byte(_ptr++); return pgm_read_byte(_ptr++);
else else
return -1; return -1;
} }
size_t readBytes(char* buffer, size_t length) { size_t readBytes(char* buffer, size_t length) {
size_t available = static_cast<size_t>(_end - _ptr); size_t available = static_cast<size_t>(_end - _ptr);
if (available < length) if (available < length)
length = available; length = available;
memcpy_P(buffer, _ptr, length); memcpy_P(buffer, _ptr, length);
_ptr += length; _ptr += length;
return length; return length;
} }
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

86
lib_standalone/ArduinoJson/src/ArduinoJson/Deserialization/Readers/IteratorReader.hpp → lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/IteratorReader.hpp
View File

@@ -1,43 +1,43 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TIterator> template <typename TIterator>
class IteratorReader { class IteratorReader {
TIterator _ptr, _end; TIterator _ptr, _end;
public: public:
explicit IteratorReader(TIterator begin, TIterator end) explicit IteratorReader(TIterator begin, TIterator end)
: _ptr(begin), _end(end) {} : _ptr(begin), _end(end) {}
int read() { int read() {
if (_ptr < _end) if (_ptr < _end)
return static_cast<unsigned char>(*_ptr++); return static_cast<unsigned char>(*_ptr++);
else else
return -1; return -1;
} }
size_t readBytes(char* buffer, size_t length) { size_t readBytes(char* buffer, size_t length) {
size_t i = 0; size_t i = 0;
while (i < length && _ptr < _end) buffer[i++] = *_ptr++; while (i < length && _ptr < _end) buffer[i++] = *_ptr++;
return i; return i;
} }
}; };
template <typename T> template <typename T>
struct void_ { struct void_ {
typedef void type; typedef void type;
}; };
template <typename TSource> template <typename TSource>
struct Reader<TSource, typename void_<typename TSource::const_iterator>::type> struct Reader<TSource, typename void_<typename TSource::const_iterator>::type>
: IteratorReader<typename TSource::const_iterator> { : IteratorReader<typename TSource::const_iterator> {
explicit Reader(const TSource& source) explicit Reader(const TSource& source)
: IteratorReader<typename TSource::const_iterator>(source.begin(), : IteratorReader<typename TSource::const_iterator>(source.begin(),
source.end()) {} source.end()) {}
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

100
lib_standalone/ArduinoJson/src/ArduinoJson/Deserialization/Readers/RamReader.hpp → lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/RamReader.hpp
View File

@@ -1,50 +1,50 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Polyfills/type_traits.hpp> #include <ArduinoJson/Polyfills/type_traits.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename T> template <typename T>
struct IsCharOrVoid { struct IsCharOrVoid {
static const bool value = static const bool value =
is_same<T, void>::value || is_same<T, char>::value || is_same<T, void>::value || is_same<T, char>::value ||
is_same<T, unsigned char>::value || is_same<T, signed char>::value; is_same<T, unsigned char>::value || is_same<T, signed char>::value;
}; };
template <typename T> template <typename T>
struct IsCharOrVoid<const T> : IsCharOrVoid<T> {}; struct IsCharOrVoid<const T> : IsCharOrVoid<T> {};
template <typename TSource> template <typename TSource>
struct Reader<TSource*, struct Reader<TSource*,
typename enable_if<IsCharOrVoid<TSource>::value>::type> { typename enable_if<IsCharOrVoid<TSource>::value>::type> {
const char* _ptr; const char* _ptr;
public: public:
explicit Reader(const void* ptr) explicit Reader(const void* ptr)
: _ptr(ptr ? reinterpret_cast<const char*>(ptr) : "") {} : _ptr(ptr ? reinterpret_cast<const char*>(ptr) : "") {}
int read() { int read() {
return static_cast<unsigned char>(*_ptr++); return static_cast<unsigned char>(*_ptr++);
} }
size_t readBytes(char* buffer, size_t length) { size_t readBytes(char* buffer, size_t length) {
for (size_t i = 0; i < length; i++) buffer[i] = *_ptr++; for (size_t i = 0; i < length; i++) buffer[i] = *_ptr++;
return length; return length;
} }
}; };
template <typename TSource> template <typename TSource>
struct BoundedReader<TSource*, struct BoundedReader<TSource*,
typename enable_if<IsCharOrVoid<TSource>::value>::type> typename enable_if<IsCharOrVoid<TSource>::value>::type>
: public IteratorReader<const char*> { : public IteratorReader<const char*> {
public: public:
explicit BoundedReader(const void* ptr, size_t len) explicit BoundedReader(const void* ptr, size_t len)
: IteratorReader<const char*>(reinterpret_cast<const char*>(ptr), : IteratorReader<const char*>(reinterpret_cast<const char*>(ptr),
reinterpret_cast<const char*>(ptr) + len) {} reinterpret_cast<const char*>(ptr) + len) {}
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

58
lib_standalone/ArduinoJson/src/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp → lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp
View File

@@ -1,29 +1,29 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <istream> #include <istream>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TSource> template <typename TSource>
struct Reader<TSource, typename enable_if< struct Reader<TSource, typename enable_if<
is_base_of<std::istream, TSource>::value>::type> { is_base_of<std::istream, TSource>::value>::type> {
public: public:
explicit Reader(std::istream& stream) : _stream(&stream) {} explicit Reader(std::istream& stream) : _stream(&stream) {}
int read() { int read() {
return _stream->get(); return _stream->get();
} }
size_t readBytes(char* buffer, size_t length) { size_t readBytes(char* buffer, size_t length) {
_stream->read(buffer, static_cast<std::streamsize>(length)); _stream->read(buffer, static_cast<std::streamsize>(length));
return static_cast<size_t>(_stream->gcount()); return static_cast<size_t>(_stream->gcount());
} }
private: private:
std::istream* _stream; std::istream* _stream;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

34
lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/VariantReader.hpp Normal file
View File

@@ -0,0 +1,34 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020
// MIT License
#pragma once
#include <ArduinoJson/Object/MemberProxy.hpp>
#include <ArduinoJson/Variant/VariantRef.hpp>
namespace ARDUINOJSON_NAMESPACE {
template <typename TArray>
struct Reader<ElementProxy<TArray>, void> : Reader<char*, void> {
explicit Reader(const ElementProxy<TArray>& x)
: Reader<char*, void>(x.template as<const char*>()) {}
};
template <typename TObject, typename TStringRef>
struct Reader<MemberProxy<TObject, TStringRef>, void> : Reader<char*, void> {
explicit Reader(const MemberProxy<TObject, TStringRef>& x)
: Reader<char*, void>(x.template as<const char*>()) {}
};
template <>
struct Reader<VariantRef, void> : Reader<char*, void> {
explicit Reader(VariantRef x) : Reader<char*, void>(x.as<const char*>()) {}
};
template <>
struct Reader<VariantConstRef, void> : Reader<char*, void> {
explicit Reader(VariantConstRef x)
: Reader<char*, void>(x.as<const char*>()) {}
};
} // namespace ARDUINOJSON_NAMESPACE

139
lib_standalone/ArduinoJson/src/ArduinoJson/Deserialization/deserialize.hpp → lib/ArduinoJson/src/ArduinoJson/Deserialization/deserialize.hpp
View File

@@ -1,71 +1,68 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Deserialization/DeserializationError.hpp> #include <ArduinoJson/Deserialization/DeserializationError.hpp>
#include <ArduinoJson/Deserialization/Filter.hpp> #include <ArduinoJson/Deserialization/Filter.hpp>
#include <ArduinoJson/Deserialization/NestingLimit.hpp> #include <ArduinoJson/Deserialization/NestingLimit.hpp>
#include <ArduinoJson/Deserialization/Reader.hpp> #include <ArduinoJson/Deserialization/Reader.hpp>
#include <ArduinoJson/StringStorage/StringStorage.hpp> #include <ArduinoJson/StringStorage/StringStorage.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <template <typename, typename> class TDeserializer, typename TReader, template <template <typename, typename> class TDeserializer, typename TReader,
typename TWriter> typename TWriter>
TDeserializer<TReader, TWriter> makeDeserializer(MemoryPool &pool, TDeserializer<TReader, TWriter> makeDeserializer(MemoryPool &pool,
TReader reader, TReader reader,
TWriter writer) { TWriter writer) {
return TDeserializer<TReader, TWriter>(pool, reader, writer); return TDeserializer<TReader, TWriter>(pool, reader, writer);
} }
// deserialize(JsonDocument&, const std::string&, NestingLimit, Filter); // deserialize(JsonDocument&, const std::string&, NestingLimit, Filter);
// deserialize(JsonDocument&, const String&, NestingLimit, Filter); // deserialize(JsonDocument&, const String&, NestingLimit, Filter);
// deserialize(JsonDocument&, char*, NestingLimit, Filter); // deserialize(JsonDocument&, char*, NestingLimit, Filter);
// deserialize(JsonDocument&, const char*, NestingLimit, Filter); // deserialize(JsonDocument&, const char*, NestingLimit, Filter);
// deserialize(JsonDocument&, const __FlashStringHelper*, NestingLimit, Filter); // deserialize(JsonDocument&, const __FlashStringHelper*, NestingLimit, Filter);
template <template <typename, typename> class TDeserializer, typename TString, template <template <typename, typename> class TDeserializer, typename TString,
typename TFilter> typename TFilter>
typename enable_if<!is_array<TString>::value, DeserializationError>::type typename enable_if<!is_array<TString>::value, DeserializationError>::type
deserialize(JsonDocument &doc, const TString &input, NestingLimit nestingLimit, deserialize(JsonDocument &doc, const TString &input, NestingLimit nestingLimit,
TFilter filter) { TFilter filter) {
Reader<TString> reader(input); Reader<TString> reader(input);
doc.clear(); doc.clear();
return makeDeserializer<TDeserializer>( return makeDeserializer<TDeserializer>(doc.memoryPool(), reader,
doc.memoryPool(), reader, makeStringStorage(input))
makeStringStorage(doc.memoryPool(), input)) .parse(doc.data(), filter, nestingLimit);
.parse(doc.data(), filter, nestingLimit); }
} //
// // deserialize(JsonDocument&, char*, size_t, NestingLimit, Filter);
// deserialize(JsonDocument&, char*, size_t, NestingLimit, Filter); // deserialize(JsonDocument&, const char*, size_t, NestingLimit, Filter);
// deserialize(JsonDocument&, const char*, size_t, NestingLimit, Filter); // deserialize(JsonDocument&, const __FlashStringHelper*, size_t, NL, Filter);
// deserialize(JsonDocument&, const __FlashStringHelper*, size_t, NL, Filter); template <template <typename, typename> class TDeserializer, typename TChar,
template <template <typename, typename> class TDeserializer, typename TChar, typename TFilter>
typename TFilter> DeserializationError deserialize(JsonDocument &doc, TChar *input,
DeserializationError deserialize(JsonDocument &doc, TChar *input, size_t inputSize, NestingLimit nestingLimit,
size_t inputSize, NestingLimit nestingLimit, TFilter filter) {
TFilter filter) { BoundedReader<TChar *> reader(input, inputSize);
BoundedReader<TChar *> reader(input, inputSize); doc.clear();
doc.clear(); return makeDeserializer<TDeserializer>(doc.memoryPool(), reader,
return makeDeserializer<TDeserializer>( makeStringStorage(input))
doc.memoryPool(), reader, .parse(doc.data(), filter, nestingLimit);
makeStringStorage(doc.memoryPool(), input)) }
.parse(doc.data(), filter, nestingLimit); //
} // deserialize(JsonDocument&, std::istream&, NestingLimit, Filter);
// // deserialize(JsonDocument&, Stream&, NestingLimit, Filter);
// deserialize(JsonDocument&, std::istream&, NestingLimit, Filter); template <template <typename, typename> class TDeserializer, typename TStream,
// deserialize(JsonDocument&, Stream&, NestingLimit, Filter); typename TFilter>
template <template <typename, typename> class TDeserializer, typename TStream, DeserializationError deserialize(JsonDocument &doc, TStream &input,
typename TFilter> NestingLimit nestingLimit, TFilter filter) {
DeserializationError deserialize(JsonDocument &doc, TStream &input, Reader<TStream> reader(input);
NestingLimit nestingLimit, TFilter filter) { doc.clear();
Reader<TStream> reader(input); return makeDeserializer<TDeserializer>(doc.memoryPool(), reader,
doc.clear(); makeStringStorage(input))
return makeDeserializer<TDeserializer>( .parse(doc.data(), filter, nestingLimit);
doc.memoryPool(), reader, }
makeStringStorage(doc.memoryPool(), input))
.parse(doc.data(), filter, nestingLimit); } // namespace ARDUINOJSON_NAMESPACE
}
} // namespace ARDUINOJSON_NAMESPACE

328
lib_standalone/ArduinoJson/src/ArduinoJson/Document/BasicJsonDocument.hpp → lib/ArduinoJson/src/ArduinoJson/Document/BasicJsonDocument.hpp
View File

@@ -1,164 +1,164 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Document/JsonDocument.hpp> #include <ArduinoJson/Document/JsonDocument.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
// Helper to implement the "base-from-member" idiom // Helper to implement the "base-from-member" idiom
// (we need to store the allocator before constructing JsonDocument) // (we need to store the allocator before constructing JsonDocument)
template <typename TAllocator> template <typename TAllocator>
class AllocatorOwner { class AllocatorOwner {
public: public:
AllocatorOwner() {} AllocatorOwner() {}
AllocatorOwner(const AllocatorOwner& src) : _allocator(src._allocator) {} AllocatorOwner(const AllocatorOwner& src) : _allocator(src._allocator) {}
AllocatorOwner(TAllocator a) : _allocator(a) {} AllocatorOwner(TAllocator a) : _allocator(a) {}
void* allocate(size_t size) { void* allocate(size_t size) {
return _allocator.allocate(size); return _allocator.allocate(size);
} }
void deallocate(void* ptr) { void deallocate(void* ptr) {
if (ptr) if (ptr)
_allocator.deallocate(ptr); _allocator.deallocate(ptr);
} }
void* reallocate(void* ptr, size_t new_size) { void* reallocate(void* ptr, size_t new_size) {
return _allocator.reallocate(ptr, new_size); return _allocator.reallocate(ptr, new_size);
} }
TAllocator& allocator() { TAllocator& allocator() {
return _allocator; return _allocator;
} }
private: private:
TAllocator _allocator; TAllocator _allocator;
}; };
template <typename TAllocator> template <typename TAllocator>
class BasicJsonDocument : AllocatorOwner<TAllocator>, public JsonDocument { class BasicJsonDocument : AllocatorOwner<TAllocator>, public JsonDocument {
public: public:
explicit BasicJsonDocument(size_t capa, TAllocator alloc = TAllocator()) explicit BasicJsonDocument(size_t capa, TAllocator alloc = TAllocator())
: AllocatorOwner<TAllocator>(alloc), JsonDocument(allocPool(capa)) {} : AllocatorOwner<TAllocator>(alloc), JsonDocument(allocPool(capa)) {}
// Copy-constructor // Copy-constructor
BasicJsonDocument(const BasicJsonDocument& src) BasicJsonDocument(const BasicJsonDocument& src)
: AllocatorOwner<TAllocator>(src), JsonDocument() { : AllocatorOwner<TAllocator>(src), JsonDocument() {
copyAssignFrom(src); copyAssignFrom(src);
} }
// Move-constructor // Move-constructor
#if ARDUINOJSON_HAS_RVALUE_REFERENCES #if ARDUINOJSON_HAS_RVALUE_REFERENCES
BasicJsonDocument(BasicJsonDocument&& src) : AllocatorOwner<TAllocator>(src) { BasicJsonDocument(BasicJsonDocument&& src) : AllocatorOwner<TAllocator>(src) {
moveAssignFrom(src); moveAssignFrom(src);
} }
#endif #endif
BasicJsonDocument(const JsonDocument& src) { BasicJsonDocument(const JsonDocument& src) {
copyAssignFrom(src); copyAssignFrom(src);
} }
// Construct from variant, array, or object // Construct from variant, array, or object
template <typename T> template <typename T>
BasicJsonDocument( BasicJsonDocument(
const T& src, const T& src,
typename enable_if< typename enable_if<
is_same<T, VariantRef>::value || is_same<T, VariantConstRef>::value || is_same<T, VariantRef>::value || is_same<T, VariantConstRef>::value ||
is_same<T, ArrayRef>::value || is_same<T, ArrayConstRef>::value || is_same<T, ArrayRef>::value || is_same<T, ArrayConstRef>::value ||
is_same<T, ObjectRef>::value || is_same<T, ObjectRef>::value ||
is_same<T, ObjectConstRef>::value>::type* = 0) is_same<T, ObjectConstRef>::value>::type* = 0)
: JsonDocument(allocPool(src.memoryUsage())) { : JsonDocument(allocPool(src.memoryUsage())) {
set(src); set(src);
} }
// disambiguate // disambiguate
BasicJsonDocument(VariantRef src) BasicJsonDocument(VariantRef src)
: JsonDocument(allocPool(src.memoryUsage())) { : JsonDocument(allocPool(src.memoryUsage())) {
set(src); set(src);
} }
~BasicJsonDocument() { ~BasicJsonDocument() {
freePool(); freePool();
} }
BasicJsonDocument& operator=(const BasicJsonDocument& src) { BasicJsonDocument& operator=(const BasicJsonDocument& src) {
copyAssignFrom(src); copyAssignFrom(src);
return *this; return *this;
} }
#if ARDUINOJSON_HAS_RVALUE_REFERENCES #if ARDUINOJSON_HAS_RVALUE_REFERENCES
BasicJsonDocument& operator=(BasicJsonDocument&& src) { BasicJsonDocument& operator=(BasicJsonDocument&& src) {
moveAssignFrom(src); moveAssignFrom(src);
return *this; return *this;
} }
#endif #endif
template <typename T> template <typename T>
BasicJsonDocument& operator=(const T& src) { BasicJsonDocument& operator=(const T& src) {
reallocPoolIfTooSmall(src.memoryUsage()); reallocPoolIfTooSmall(src.memoryUsage());
set(src); set(src);
return *this; return *this;
} }
void shrinkToFit() { void shrinkToFit() {
ptrdiff_t bytes_reclaimed = _pool.squash(); ptrdiff_t bytes_reclaimed = _pool.squash();
if (bytes_reclaimed == 0) if (bytes_reclaimed == 0)
return; return;
void* old_ptr = _pool.buffer(); void* old_ptr = _pool.buffer();
void* new_ptr = this->reallocate(old_ptr, _pool.capacity()); void* new_ptr = this->reallocate(old_ptr, _pool.capacity());
ptrdiff_t ptr_offset = ptrdiff_t ptr_offset =
static_cast<char*>(new_ptr) - static_cast<char*>(old_ptr); static_cast<char*>(new_ptr) - static_cast<char*>(old_ptr);
_pool.movePointers(ptr_offset); _pool.movePointers(ptr_offset);
_data.movePointers(ptr_offset, ptr_offset - bytes_reclaimed); _data.movePointers(ptr_offset, ptr_offset - bytes_reclaimed);
} }
bool garbageCollect() { bool garbageCollect() {
// make a temporary clone and move assign // make a temporary clone and move assign
BasicJsonDocument tmp(*this); BasicJsonDocument tmp(*this);
if (!tmp.capacity()) if (!tmp.capacity())
return false; return false;
tmp.set(*this); tmp.set(*this);
moveAssignFrom(tmp); moveAssignFrom(tmp);
return true; return true;
} }
using AllocatorOwner<TAllocator>::allocator; using AllocatorOwner<TAllocator>::allocator;
private: private:
MemoryPool allocPool(size_t requiredSize) { MemoryPool allocPool(size_t requiredSize) {
size_t capa = addPadding(requiredSize); size_t capa = addPadding(requiredSize);
return MemoryPool(reinterpret_cast<char*>(this->allocate(capa)), capa); return MemoryPool(reinterpret_cast<char*>(this->allocate(capa)), capa);
} }
void reallocPoolIfTooSmall(size_t requiredSize) { void reallocPoolIfTooSmall(size_t requiredSize) {
if (requiredSize <= capacity()) if (requiredSize <= capacity())
return; return;
freePool(); freePool();
replacePool(allocPool(addPadding(requiredSize))); replacePool(allocPool(addPadding(requiredSize)));
} }
void freePool() { void freePool() {
this->deallocate(memoryPool().buffer()); this->deallocate(memoryPool().buffer());
} }
void copyAssignFrom(const JsonDocument& src) { void copyAssignFrom(const JsonDocument& src) {
reallocPoolIfTooSmall(src.capacity()); reallocPoolIfTooSmall(src.capacity());
set(src); set(src);
} }
void moveAssignFrom(BasicJsonDocument& src) { void moveAssignFrom(BasicJsonDocument& src) {
freePool(); freePool();
_data = src._data; _data = src._data;
_pool = src._pool; _pool = src._pool;
src._data.setNull(); src._data.setNull();
src._pool = MemoryPool(0, 0); src._pool = MemoryPool(0, 0);
} }
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

58
lib_standalone/ArduinoJson/src/ArduinoJson/Document/DynamicJsonDocument.hpp → lib/ArduinoJson/src/ArduinoJson/Document/DynamicJsonDocument.hpp
View File

@@ -1,29 +1,29 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Document/BasicJsonDocument.hpp> #include <ArduinoJson/Document/BasicJsonDocument.hpp>
#include <stdlib.h> // malloc, free #include <stdlib.h> // malloc, free
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
struct DefaultAllocator { struct DefaultAllocator {
void* allocate(size_t size) { void* allocate(size_t size) {
return malloc(size); return malloc(size);
} }
void deallocate(void* ptr) { void deallocate(void* ptr) {
free(ptr); free(ptr);
} }
void* reallocate(void* ptr, size_t new_size) { void* reallocate(void* ptr, size_t new_size) {
return realloc(ptr, new_size); return realloc(ptr, new_size);
} }
}; };
typedef BasicJsonDocument<DefaultAllocator> DynamicJsonDocument; typedef BasicJsonDocument<DefaultAllocator> DynamicJsonDocument;
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

656
lib_standalone/ArduinoJson/src/ArduinoJson/Document/JsonDocument.hpp → lib/ArduinoJson/src/ArduinoJson/Document/JsonDocument.hpp
View File

@@ -1,328 +1,328 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Array/ElementProxy.hpp> #include <ArduinoJson/Array/ElementProxy.hpp>
#include <ArduinoJson/Memory/MemoryPool.hpp> #include <ArduinoJson/Memory/MemoryPool.hpp>
#include <ArduinoJson/Object/MemberProxy.hpp> #include <ArduinoJson/Object/MemberProxy.hpp>
#include <ArduinoJson/Object/ObjectRef.hpp> #include <ArduinoJson/Object/ObjectRef.hpp>
#include <ArduinoJson/Variant/VariantRef.hpp> #include <ArduinoJson/Variant/VariantRef.hpp>
#include <ArduinoJson/Variant/VariantTo.hpp> #include <ArduinoJson/Variant/VariantTo.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
class JsonDocument : public Visitable { class JsonDocument : public Visitable {
public: public:
template <typename Visitor> template <typename Visitor>
void accept(Visitor& visitor) const { void accept(Visitor& visitor) const {
return getVariant().accept(visitor); return getVariant().accept(visitor);
} }
template <typename T> template <typename T>
typename VariantAs<T>::type as() { typename VariantAs<T>::type as() {
return getVariant().template as<T>(); return getVariant().template as<T>();
} }
template <typename T> template <typename T>
typename VariantConstAs<T>::type as() const { typename VariantConstAs<T>::type as() const {
return getVariant().template as<T>(); return getVariant().template as<T>();
} }
void clear() { void clear() {
_pool.clear(); _pool.clear();
_data.setNull(); _data.setNull();
} }
template <typename T> template <typename T>
bool is() const { bool is() const {
return getVariant().template is<T>(); return getVariant().template is<T>();
} }
bool isNull() const { bool isNull() const {
return getVariant().isNull(); return getVariant().isNull();
} }
size_t memoryUsage() const { size_t memoryUsage() const {
return _pool.size(); return _pool.size();
} }
size_t nesting() const { size_t nesting() const {
return _data.nesting(); return _data.nesting();
} }
size_t capacity() const { size_t capacity() const {
return _pool.capacity(); return _pool.capacity();
} }
size_t size() const { size_t size() const {
return _data.size(); return _data.size();
} }
bool set(const JsonDocument& src) { bool set(const JsonDocument& src) {
return to<VariantRef>().set(src.as<VariantRef>()); return to<VariantRef>().set(src.as<VariantRef>());
} }
template <typename T> template <typename T>
typename enable_if<!is_base_of<JsonDocument, T>::value, bool>::type set( typename enable_if<!is_base_of<JsonDocument, T>::value, bool>::type set(
const T& src) { const T& src) {
return to<VariantRef>().set(src); return to<VariantRef>().set(src);
} }
template <typename T> template <typename T>
typename VariantTo<T>::type to() { typename VariantTo<T>::type to() {
clear(); clear();
return getVariant().template to<T>(); return getVariant().template to<T>();
} }
// for internal use only // for internal use only
MemoryPool& memoryPool() { MemoryPool& memoryPool() {
return _pool; return _pool;
} }
VariantData& data() { VariantData& data() {
return _data; return _data;
} }
ArrayRef createNestedArray() { ArrayRef createNestedArray() {
return addElement().to<ArrayRef>(); return addElement().to<ArrayRef>();
} }
// createNestedArray(char*) // createNestedArray(char*)
// createNestedArray(const char*) // createNestedArray(const char*)
// createNestedArray(const __FlashStringHelper*) // createNestedArray(const __FlashStringHelper*)
template <typename TChar> template <typename TChar>
ArrayRef createNestedArray(TChar* key) { ArrayRef createNestedArray(TChar* key) {
return getOrAddMember(key).template to<ArrayRef>(); return getOrAddMember(key).template to<ArrayRef>();
} }
// createNestedArray(const std::string&) // createNestedArray(const std::string&)
// createNestedArray(const String&) // createNestedArray(const String&)
template <typename TString> template <typename TString>
ArrayRef createNestedArray(const TString& key) { ArrayRef createNestedArray(const TString& key) {
return getOrAddMember(key).template to<ArrayRef>(); return getOrAddMember(key).template to<ArrayRef>();
} }
ObjectRef createNestedObject() { ObjectRef createNestedObject() {
return addElement().to<ObjectRef>(); return addElement().to<ObjectRef>();
} }
// createNestedObject(char*) // createNestedObject(char*)
// createNestedObject(const char*) // createNestedObject(const char*)
// createNestedObject(const __FlashStringHelper*) // createNestedObject(const __FlashStringHelper*)
template <typename TChar> template <typename TChar>
ObjectRef createNestedObject(TChar* key) { ObjectRef createNestedObject(TChar* key) {
return getOrAddMember(key).template to<ObjectRef>(); return getOrAddMember(key).template to<ObjectRef>();
} }
// createNestedObject(const std::string&) // createNestedObject(const std::string&)
// createNestedObject(const String&) // createNestedObject(const String&)
template <typename TString> template <typename TString>
ObjectRef createNestedObject(const TString& key) { ObjectRef createNestedObject(const TString& key) {
return getOrAddMember(key).template to<ObjectRef>(); return getOrAddMember(key).template to<ObjectRef>();
} }
// containsKey(char*) const // containsKey(char*) const
// containsKey(const char*) const // containsKey(const char*) const
// containsKey(const __FlashStringHelper*) const // containsKey(const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
bool containsKey(TChar* key) const { bool containsKey(TChar* key) const {
return !getMember(key).isUndefined(); return !getMember(key).isUndefined();
} }
// containsKey(const std::string&) const // containsKey(const std::string&) const
// containsKey(const String&) const // containsKey(const String&) const
template <typename TString> template <typename TString>
bool containsKey(const TString& key) const { bool containsKey(const TString& key) const {
return !getMember(key).isUndefined(); return !getMember(key).isUndefined();
} }
// operator[](const std::string&) // operator[](const std::string&)
// operator[](const String&) // operator[](const String&)
template <typename TString> template <typename TString>
FORCE_INLINE typename enable_if<IsString<TString>::value, FORCE_INLINE typename enable_if<IsString<TString>::value,
MemberProxy<JsonDocument&, TString> >::type MemberProxy<JsonDocument&, TString> >::type
operator[](const TString& key) { operator[](const TString& key) {
return MemberProxy<JsonDocument&, TString>(*this, key); return MemberProxy<JsonDocument&, TString>(*this, key);
} }
// operator[](char*) // operator[](char*)
// operator[](const char*) // operator[](const char*)
// operator[](const __FlashStringHelper*) // operator[](const __FlashStringHelper*)
template <typename TChar> template <typename TChar>
FORCE_INLINE typename enable_if<IsString<TChar*>::value, FORCE_INLINE typename enable_if<IsString<TChar*>::value,
MemberProxy<JsonDocument&, TChar*> >::type MemberProxy<JsonDocument&, TChar*> >::type
operator[](TChar* key) { operator[](TChar* key) {
return MemberProxy<JsonDocument&, TChar*>(*this, key); return MemberProxy<JsonDocument&, TChar*>(*this, key);
} }
// operator[](const std::string&) const // operator[](const std::string&) const
// operator[](const String&) const // operator[](const String&) const
template <typename TString> template <typename TString>
FORCE_INLINE FORCE_INLINE
typename enable_if<IsString<TString>::value, VariantConstRef>::type typename enable_if<IsString<TString>::value, VariantConstRef>::type
operator[](const TString& key) const { operator[](const TString& key) const {
return getMember(key); return getMember(key);
} }
// operator[](char*) const // operator[](char*) const
// operator[](const char*) const // operator[](const char*) const
// operator[](const __FlashStringHelper*) const // operator[](const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
FORCE_INLINE FORCE_INLINE
typename enable_if<IsString<TChar*>::value, VariantConstRef>::type typename enable_if<IsString<TChar*>::value, VariantConstRef>::type
operator[](TChar* key) const { operator[](TChar* key) const {
return getMember(key); return getMember(key);
} }
FORCE_INLINE ElementProxy<JsonDocument&> operator[](size_t index) { FORCE_INLINE ElementProxy<JsonDocument&> operator[](size_t index) {
return ElementProxy<JsonDocument&>(*this, index); return ElementProxy<JsonDocument&>(*this, index);
} }
FORCE_INLINE VariantConstRef operator[](size_t index) const { FORCE_INLINE VariantConstRef operator[](size_t index) const {
return getElement(index); return getElement(index);
} }
FORCE_INLINE VariantRef getElement(size_t index) { FORCE_INLINE VariantRef getElement(size_t index) {
return VariantRef(&_pool, _data.getElement(index)); return VariantRef(&_pool, _data.getElement(index));
} }
FORCE_INLINE VariantConstRef getElement(size_t index) const { FORCE_INLINE VariantConstRef getElement(size_t index) const {
return VariantConstRef(_data.getElement(index)); return VariantConstRef(_data.getElement(index));
} }
FORCE_INLINE VariantRef getOrAddElement(size_t index) { FORCE_INLINE VariantRef getOrAddElement(size_t index) {
return VariantRef(&_pool, _data.getOrAddElement(index, &_pool)); return VariantRef(&_pool, _data.getOrAddElement(index, &_pool));
} }
// JsonVariantConst getMember(char*) const // JsonVariantConst getMember(char*) const
// JsonVariantConst getMember(const char*) const // JsonVariantConst getMember(const char*) const
// JsonVariantConst getMember(const __FlashStringHelper*) const // JsonVariantConst getMember(const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
FORCE_INLINE VariantConstRef getMember(TChar* key) const { FORCE_INLINE VariantConstRef getMember(TChar* key) const {
return VariantConstRef(_data.getMember(adaptString(key))); return VariantConstRef(_data.getMember(adaptString(key)));
} }
// JsonVariantConst getMember(const std::string&) const // JsonVariantConst getMember(const std::string&) const
// JsonVariantConst getMember(const String&) const // JsonVariantConst getMember(const String&) const
template <typename TString> template <typename TString>
FORCE_INLINE FORCE_INLINE
typename enable_if<IsString<TString>::value, VariantConstRef>::type typename enable_if<IsString<TString>::value, VariantConstRef>::type
getMember(const TString& key) const { getMember(const TString& key) const {
return VariantConstRef(_data.getMember(adaptString(key))); return VariantConstRef(_data.getMember(adaptString(key)));
} }
// JsonVariant getMember(char*) // JsonVariant getMember(char*)
// JsonVariant getMember(const char*) // JsonVariant getMember(const char*)
// JsonVariant getMember(const __FlashStringHelper*) // JsonVariant getMember(const __FlashStringHelper*)
template <typename TChar> template <typename TChar>
FORCE_INLINE VariantRef getMember(TChar* key) { FORCE_INLINE VariantRef getMember(TChar* key) {
return VariantRef(&_pool, _data.getMember(adaptString(key))); return VariantRef(&_pool, _data.getMember(adaptString(key)));
} }
// JsonVariant getMember(const std::string&) // JsonVariant getMember(const std::string&)
// JsonVariant getMember(const String&) // JsonVariant getMember(const String&)
template <typename TString> template <typename TString>
FORCE_INLINE typename enable_if<IsString<TString>::value, VariantRef>::type FORCE_INLINE typename enable_if<IsString<TString>::value, VariantRef>::type
getMember(const TString& key) { getMember(const TString& key) {
return VariantRef(&_pool, _data.getMember(adaptString(key))); return VariantRef(&_pool, _data.getMember(adaptString(key)));
} }
// getOrAddMember(char*) // getOrAddMember(char*)
// getOrAddMember(const char*) // getOrAddMember(const char*)
// getOrAddMember(const __FlashStringHelper*) // getOrAddMember(const __FlashStringHelper*)
template <typename TChar> template <typename TChar>
FORCE_INLINE VariantRef getOrAddMember(TChar* key) { FORCE_INLINE VariantRef getOrAddMember(TChar* key) {
return VariantRef(&_pool, _data.getOrAddMember(adaptString(key), &_pool)); return VariantRef(&_pool, _data.getOrAddMember(adaptString(key), &_pool));
} }
// getOrAddMember(const std::string&) // getOrAddMember(const std::string&)
// getOrAddMember(const String&) // getOrAddMember(const String&)
template <typename TString> template <typename TString>
FORCE_INLINE VariantRef getOrAddMember(const TString& key) { FORCE_INLINE VariantRef getOrAddMember(const TString& key) {
return VariantRef(&_pool, _data.getOrAddMember(adaptString(key), &_pool)); return VariantRef(&_pool, _data.getOrAddMember(adaptString(key), &_pool));
} }
FORCE_INLINE VariantRef addElement() { FORCE_INLINE VariantRef addElement() {
return VariantRef(&_pool, _data.addElement(&_pool)); return VariantRef(&_pool, _data.addElement(&_pool));
} }
template <typename TValue> template <typename TValue>
FORCE_INLINE bool add(const TValue& value) { FORCE_INLINE bool add(const TValue& value) {
return addElement().set(value); return addElement().set(value);
} }
// add(char*) const // add(char*) const
// add(const char*) const // add(const char*) const
// add(const __FlashStringHelper*) const // add(const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
FORCE_INLINE bool add(TChar* value) { FORCE_INLINE bool add(TChar* value) {
return addElement().set(value); return addElement().set(value);
} }
FORCE_INLINE void remove(size_t index) { FORCE_INLINE void remove(size_t index) {
_data.remove(index); _data.remove(index);
} }
// remove(char*) // remove(char*)
// remove(const char*) // remove(const char*)
// remove(const __FlashStringHelper*) // remove(const __FlashStringHelper*)
template <typename TChar> template <typename TChar>
FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove( FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
TChar* key) { TChar* key) {
_data.remove(adaptString(key)); _data.remove(adaptString(key));
} }
// remove(const std::string&) // remove(const std::string&)
// remove(const String&) // remove(const String&)
template <typename TString> template <typename TString>
FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove( FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
const TString& key) { const TString& key) {
_data.remove(adaptString(key)); _data.remove(adaptString(key));
} }
FORCE_INLINE operator VariantConstRef() const { FORCE_INLINE operator VariantConstRef() const {
return VariantConstRef(&_data); return VariantConstRef(&_data);
} }
bool operator==(VariantConstRef rhs) const { bool operator==(VariantConstRef rhs) const {
return getVariant() == rhs; return getVariant() == rhs;
} }
bool operator!=(VariantConstRef rhs) const { bool operator!=(VariantConstRef rhs) const {
return getVariant() != rhs; return getVariant() != rhs;
} }
protected: protected:
JsonDocument() : _pool(0, 0) { JsonDocument() : _pool(0, 0) {
_data.setNull(); _data.setNull();
} }
JsonDocument(MemoryPool pool) : _pool(pool) { JsonDocument(MemoryPool pool) : _pool(pool) {
_data.setNull(); _data.setNull();
} }
JsonDocument(char* buf, size_t capa) : _pool(buf, capa) { JsonDocument(char* buf, size_t capa) : _pool(buf, capa) {
_data.setNull(); _data.setNull();
} }
void replacePool(MemoryPool pool) { void replacePool(MemoryPool pool) {
_pool = pool; _pool = pool;
} }
VariantRef getVariant() { VariantRef getVariant() {
return VariantRef(&_pool, &_data); return VariantRef(&_pool, &_data);
} }
VariantConstRef getVariant() const { VariantConstRef getVariant() const {
return VariantConstRef(&_data); return VariantConstRef(&_data);
} }
MemoryPool _pool; MemoryPool _pool;
VariantData _data; VariantData _data;
private: private:
JsonDocument(const JsonDocument&); JsonDocument(const JsonDocument&);
JsonDocument& operator=(const JsonDocument&); JsonDocument& operator=(const JsonDocument&);
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

112
lib_standalone/ArduinoJson/src/ArduinoJson/Document/StaticJsonDocument.hpp → lib/ArduinoJson/src/ArduinoJson/Document/StaticJsonDocument.hpp
View File

@@ -1,56 +1,56 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Document/JsonDocument.hpp> #include <ArduinoJson/Document/JsonDocument.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <size_t desiredCapacity> template <size_t desiredCapacity>
class StaticJsonDocument : public JsonDocument { class StaticJsonDocument : public JsonDocument {
static const size_t _capacity = static const size_t _capacity =
AddPadding<Max<1, desiredCapacity>::value>::value; AddPadding<Max<1, desiredCapacity>::value>::value;
public: public:
StaticJsonDocument() : JsonDocument(_buffer, _capacity) {} StaticJsonDocument() : JsonDocument(_buffer, _capacity) {}
StaticJsonDocument(const StaticJsonDocument& src) StaticJsonDocument(const StaticJsonDocument& src)
: JsonDocument(_buffer, _capacity) { : JsonDocument(_buffer, _capacity) {
set(src); set(src);
} }
template <typename T> template <typename T>
StaticJsonDocument(const T& src, StaticJsonDocument(const T& src,
typename enable_if<IsVisitable<T>::value>::type* = 0) typename enable_if<IsVisitable<T>::value>::type* = 0)
: JsonDocument(_buffer, _capacity) { : JsonDocument(_buffer, _capacity) {
set(src); set(src);
} }
// disambiguate // disambiguate
StaticJsonDocument(VariantRef src) : JsonDocument(_buffer, _capacity) { StaticJsonDocument(VariantRef src) : JsonDocument(_buffer, _capacity) {
set(src); set(src);
} }
StaticJsonDocument operator=(const StaticJsonDocument& src) { StaticJsonDocument operator=(const StaticJsonDocument& src) {
set(src); set(src);
return *this; return *this;
} }
template <typename T> template <typename T>
StaticJsonDocument operator=(const T& src) { StaticJsonDocument operator=(const T& src) {
set(src); set(src);
return *this; return *this;
} }
void garbageCollect() { void garbageCollect() {
StaticJsonDocument tmp(*this); StaticJsonDocument tmp(*this);
set(tmp); set(tmp);
} }
private: private:
char _buffer[_capacity]; char _buffer[_capacity];
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

78
lib_standalone/ArduinoJson/src/ArduinoJson/Json/EscapeSequence.hpp → lib/ArduinoJson/src/ArduinoJson/Json/EscapeSequence.hpp
View File

@@ -1,39 +1,39 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
class EscapeSequence { class EscapeSequence {
public: public:
// Optimized for code size on a 8-bit AVR // Optimized for code size on a 8-bit AVR
static char escapeChar(char c) { static char escapeChar(char c) {
const char *p = escapeTable(true); const char *p = escapeTable(true);
while (p[0] && p[1] != c) { while (p[0] && p[1] != c) {
p += 2; p += 2;
} }
return p[0]; return p[0];
} }
// Optimized for code size on a 8-bit AVR // Optimized for code size on a 8-bit AVR
static char unescapeChar(char c) { static char unescapeChar(char c) {
const char *p = escapeTable(false); const char *p = escapeTable(false);
for (;;) { for (;;) {
if (p[0] == '\0') if (p[0] == '\0')
return 0; return 0;
if (p[0] == c) if (p[0] == c)
return p[1]; return p[1];
p += 2; p += 2;
} }
} }
private: private:
static const char *escapeTable(bool excludeSolidus) { static const char *escapeTable(bool excludeSolidus) {
return &"//\"\"\\\\b\bf\fn\nr\rt\t"[excludeSolidus ? 2 : 0]; return &"//\"\"\\\\b\bf\fn\nr\rt\t"[excludeSolidus ? 2 : 0];
} }
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

1422
lib_standalone/ArduinoJson/src/ArduinoJson/Json/JsonDeserializer.hpp → lib/ArduinoJson/src/ArduinoJson/Json/JsonDeserializer.hpp
View File

File diff suppressed because it is too large Load Diff

252
lib_standalone/ArduinoJson/src/ArduinoJson/Json/JsonSerializer.hpp → lib/ArduinoJson/src/ArduinoJson/Json/JsonSerializer.hpp
View File

@@ -1,126 +1,126 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Json/TextFormatter.hpp> #include <ArduinoJson/Json/TextFormatter.hpp>
#include <ArduinoJson/Misc/Visitable.hpp> #include <ArduinoJson/Misc/Visitable.hpp>
#include <ArduinoJson/Serialization/measure.hpp> #include <ArduinoJson/Serialization/measure.hpp>
#include <ArduinoJson/Serialization/serialize.hpp> #include <ArduinoJson/Serialization/serialize.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TWriter> template <typename TWriter>
class JsonSerializer { class JsonSerializer {
public: public:
JsonSerializer(TWriter writer) : _formatter(writer) {} JsonSerializer(TWriter writer) : _formatter(writer) {}
FORCE_INLINE void visitArray(const CollectionData &array) { FORCE_INLINE void visitArray(const CollectionData &array) {
write('['); write('[');
VariantSlot *slot = array.head(); VariantSlot *slot = array.head();
while (slot != 0) { while (slot != 0) {
slot->data()->accept(*this); slot->data()->accept(*this);
slot = slot->next(); slot = slot->next();
if (slot == 0) if (slot == 0)
break; break;
write(','); write(',');
} }
write(']'); write(']');
} }
void visitObject(const CollectionData &object) { void visitObject(const CollectionData &object) {
write('{'); write('{');
VariantSlot *slot = object.head(); VariantSlot *slot = object.head();
while (slot != 0) { while (slot != 0) {
_formatter.writeString(slot->key()); _formatter.writeString(slot->key());
write(':'); write(':');
slot->data()->accept(*this); slot->data()->accept(*this);
slot = slot->next(); slot = slot->next();
if (slot == 0) if (slot == 0)
break; break;
write(','); write(',');
} }
write('}'); write('}');
} }
void visitFloat(Float value) { void visitFloat(Float value) {
_formatter.writeFloat(value); _formatter.writeFloat(value);
} }
void visitString(const char *value) { void visitString(const char *value) {
_formatter.writeString(value); _formatter.writeString(value);
} }
void visitRawJson(const char *data, size_t n) { void visitRawJson(const char *data, size_t n) {
_formatter.writeRaw(data, n); _formatter.writeRaw(data, n);
} }
void visitNegativeInteger(UInt value) { void visitNegativeInteger(UInt value) {
_formatter.writeNegativeInteger(value); _formatter.writeNegativeInteger(value);
} }
void visitPositiveInteger(UInt value) { void visitPositiveInteger(UInt value) {
_formatter.writePositiveInteger(value); _formatter.writePositiveInteger(value);
} }
void visitBoolean(bool value) { void visitBoolean(bool value) {
_formatter.writeBoolean(value); _formatter.writeBoolean(value);
} }
void visitNull() { void visitNull() {
_formatter.writeRaw("null"); _formatter.writeRaw("null");
} }
size_t bytesWritten() const { size_t bytesWritten() const {
return _formatter.bytesWritten(); return _formatter.bytesWritten();
} }
protected: protected:
void write(char c) { void write(char c) {
_formatter.writeRaw(c); _formatter.writeRaw(c);
} }
void write(const char *s) { void write(const char *s) {
_formatter.writeRaw(s); _formatter.writeRaw(s);
} }
private: private:
TextFormatter<TWriter> _formatter; TextFormatter<TWriter> _formatter;
}; };
template <typename TSource, typename TDestination> template <typename TSource, typename TDestination>
size_t serializeJson(const TSource &source, TDestination &destination) { size_t serializeJson(const TSource &source, TDestination &destination) {
return serialize<JsonSerializer>(source, destination); return serialize<JsonSerializer>(source, destination);
} }
template <typename TSource> template <typename TSource>
size_t serializeJson(const TSource &source, void *buffer, size_t bufferSize) { size_t serializeJson(const TSource &source, void *buffer, size_t bufferSize) {
return serialize<JsonSerializer>(source, buffer, bufferSize); return serialize<JsonSerializer>(source, buffer, bufferSize);
} }
template <typename TSource> template <typename TSource>
size_t measureJson(const TSource &source) { size_t measureJson(const TSource &source) {
return measure<JsonSerializer>(source); return measure<JsonSerializer>(source);
} }
#if ARDUINOJSON_ENABLE_STD_STREAM #if ARDUINOJSON_ENABLE_STD_STREAM
template <typename T> template <typename T>
inline typename enable_if<IsVisitable<T>::value, std::ostream &>::type inline typename enable_if<IsVisitable<T>::value, std::ostream &>::type
operator<<(std::ostream &os, const T &source) { operator<<(std::ostream &os, const T &source) {
serializeJson(source, os); serializeJson(source, os);
return os; return os;
} }
#endif #endif
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

110
lib_standalone/ArduinoJson/src/ArduinoJson/Json/Latch.hpp → lib/ArduinoJson/src/ArduinoJson/Json/Latch.hpp
View File

@@ -1,55 +1,55 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Polyfills/assert.hpp> #include <ArduinoJson/Polyfills/assert.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TReader> template <typename TReader>
class Latch { class Latch {
public: public:
Latch(TReader reader) : _reader(reader), _loaded(false) { Latch(TReader reader) : _reader(reader), _loaded(false) {
#if ARDUINOJSON_DEBUG #if ARDUINOJSON_DEBUG
_ended = false; _ended = false;
#endif #endif
} }
void clear() { void clear() {
_loaded = false; _loaded = false;
} }
int last() const { int last() const {
return _current; return _current;
} }
FORCE_INLINE char current() { FORCE_INLINE char current() {
if (!_loaded) { if (!_loaded) {
load(); load();
} }
return _current; return _current;
} }
private: private:
void load() { void load() {
ARDUINOJSON_ASSERT(!_ended); ARDUINOJSON_ASSERT(!_ended);
int c = _reader.read(); int c = _reader.read();
#if ARDUINOJSON_DEBUG #if ARDUINOJSON_DEBUG
if (c <= 0) if (c <= 0)
_ended = true; _ended = true;
#endif #endif
_current = static_cast<char>(c > 0 ? c : 0); _current = static_cast<char>(c > 0 ? c : 0);
_loaded = true; _loaded = true;
} }
TReader _reader; TReader _reader;
char _current; char _current;
bool _loaded; bool _loaded;
#if ARDUINOJSON_DEBUG #if ARDUINOJSON_DEBUG
bool _ended; bool _ended;
#endif #endif
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

170
lib_standalone/ArduinoJson/src/ArduinoJson/Json/PrettyJsonSerializer.hpp → lib/ArduinoJson/src/ArduinoJson/Json/PrettyJsonSerializer.hpp
View File

@@ -1,85 +1,85 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Configuration.hpp> #include <ArduinoJson/Configuration.hpp>
#include <ArduinoJson/Json/JsonSerializer.hpp> #include <ArduinoJson/Json/JsonSerializer.hpp>
#include <ArduinoJson/Serialization/measure.hpp> #include <ArduinoJson/Serialization/measure.hpp>
#include <ArduinoJson/Serialization/serialize.hpp> #include <ArduinoJson/Serialization/serialize.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TWriter> template <typename TWriter>
class PrettyJsonSerializer : public JsonSerializer<TWriter> { class PrettyJsonSerializer : public JsonSerializer<TWriter> {
typedef JsonSerializer<TWriter> base; typedef JsonSerializer<TWriter> base;
public: public:
PrettyJsonSerializer(TWriter &writer) : base(writer), _nesting(0) {} PrettyJsonSerializer(TWriter &writer) : base(writer), _nesting(0) {}
void visitArray(const CollectionData &array) { void visitArray(const CollectionData &array) {
VariantSlot *slot = array.head(); VariantSlot *slot = array.head();
if (!slot) if (!slot)
return base::write("[]"); return base::write("[]");
base::write("[\r\n"); base::write("[\r\n");
_nesting++; _nesting++;
while (slot != 0) { while (slot != 0) {
indent(); indent();
slot->data()->accept(*this); slot->data()->accept(*this);
slot = slot->next(); slot = slot->next();
base::write(slot ? ",\r\n" : "\r\n"); base::write(slot ? ",\r\n" : "\r\n");
} }
_nesting--; _nesting--;
indent(); indent();
base::write("]"); base::write("]");
} }
void visitObject(const CollectionData &object) { void visitObject(const CollectionData &object) {
VariantSlot *slot = object.head(); VariantSlot *slot = object.head();
if (!slot) if (!slot)
return base::write("{}"); return base::write("{}");
base::write("{\r\n"); base::write("{\r\n");
_nesting++; _nesting++;
while (slot != 0) { while (slot != 0) {
indent(); indent();
base::visitString(slot->key()); base::visitString(slot->key());
base::write(": "); base::write(": ");
slot->data()->accept(*this); slot->data()->accept(*this);
slot = slot->next(); slot = slot->next();
base::write(slot ? ",\r\n" : "\r\n"); base::write(slot ? ",\r\n" : "\r\n");
} }
_nesting--; _nesting--;
indent(); indent();
base::write("}"); base::write("}");
} }
private: private:
void indent() { void indent() {
for (uint8_t i = 0; i < _nesting; i++) base::write(ARDUINOJSON_TAB); for (uint8_t i = 0; i < _nesting; i++) base::write(ARDUINOJSON_TAB);
} }
uint8_t _nesting; uint8_t _nesting;
}; };
template <typename TSource, typename TDestination> template <typename TSource, typename TDestination>
size_t serializeJsonPretty(const TSource &source, TDestination &destination) { size_t serializeJsonPretty(const TSource &source, TDestination &destination) {
return serialize<PrettyJsonSerializer>(source, destination); return serialize<PrettyJsonSerializer>(source, destination);
} }
template <typename TSource> template <typename TSource>
size_t serializeJsonPretty(const TSource &source, void *buffer, size_t serializeJsonPretty(const TSource &source, void *buffer,
size_t bufferSize) { size_t bufferSize) {
return serialize<PrettyJsonSerializer>(source, buffer, bufferSize); return serialize<PrettyJsonSerializer>(source, buffer, bufferSize);
} }
template <typename TSource> template <typename TSource>
size_t measureJsonPretty(const TSource &source) { size_t measureJsonPretty(const TSource &source) {
return measure<PrettyJsonSerializer>(source); return measure<PrettyJsonSerializer>(source);
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

316
lib_standalone/ArduinoJson/src/ArduinoJson/Json/TextFormatter.hpp → lib/ArduinoJson/src/ArduinoJson/Json/TextFormatter.hpp
View File

@@ -1,158 +1,158 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <stdint.h> #include <stdint.h>
#include <string.h> // for strlen #include <string.h> // for strlen
#include <ArduinoJson/Json/EscapeSequence.hpp> #include <ArduinoJson/Json/EscapeSequence.hpp>
#include <ArduinoJson/Numbers/FloatParts.hpp> #include <ArduinoJson/Numbers/FloatParts.hpp>
#include <ArduinoJson/Numbers/Integer.hpp> #include <ArduinoJson/Numbers/Integer.hpp>
#include <ArduinoJson/Polyfills/assert.hpp> #include <ArduinoJson/Polyfills/assert.hpp>
#include <ArduinoJson/Polyfills/attributes.hpp> #include <ArduinoJson/Polyfills/attributes.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TWriter> template <typename TWriter>
class TextFormatter { class TextFormatter {
public: public:
explicit TextFormatter(TWriter writer) : _writer(writer), _length(0) {} explicit TextFormatter(TWriter writer) : _writer(writer), _length(0) {}
// Returns the number of bytes sent to the TWriter implementation. // Returns the number of bytes sent to the TWriter implementation.
size_t bytesWritten() const { size_t bytesWritten() const {
return _length; return _length;
} }
void writeBoolean(bool value) { void writeBoolean(bool value) {
if (value) if (value)
writeRaw("true"); writeRaw("true");
else else
writeRaw("false"); writeRaw("false");
} }
void writeString(const char *value) { void writeString(const char *value) {
ARDUINOJSON_ASSERT(value != NULL); ARDUINOJSON_ASSERT(value != NULL);
writeRaw('\"'); writeRaw('\"');
while (*value) writeChar(*value++); while (*value) writeChar(*value++);
writeRaw('\"'); writeRaw('\"');
} }
void writeChar(char c) { void writeChar(char c) {
char specialChar = EscapeSequence::escapeChar(c); char specialChar = EscapeSequence::escapeChar(c);
if (specialChar) { if (specialChar) {
writeRaw('\\'); writeRaw('\\');
writeRaw(specialChar); writeRaw(specialChar);
} else { } else {
writeRaw(c); writeRaw(c);
} }
} }
template <typename T> template <typename T>
void writeFloat(T value) { void writeFloat(T value) {
if (isnan(value)) if (isnan(value))
return writeRaw(ARDUINOJSON_ENABLE_NAN ? "NaN" : "null"); return writeRaw(ARDUINOJSON_ENABLE_NAN ? "NaN" : "null");
#if ARDUINOJSON_ENABLE_INFINITY #if ARDUINOJSON_ENABLE_INFINITY
if (value < 0.0) { if (value < 0.0) {
writeRaw('-'); writeRaw('-');
value = -value; value = -value;
} }
if (isinf(value)) if (isinf(value))
return writeRaw("Infinity"); return writeRaw("Infinity");
#else #else
if (isinf(value)) if (isinf(value))
return writeRaw("null"); return writeRaw("null");
if (value < 0.0) { if (value < 0.0) {
writeRaw('-'); writeRaw('-');
value = -value; value = -value;
} }
#endif #endif
FloatParts<T> parts(value); FloatParts<T> parts(value);
writePositiveInteger(parts.integral); writePositiveInteger(parts.integral);
if (parts.decimalPlaces) if (parts.decimalPlaces)
writeDecimals(parts.decimal, parts.decimalPlaces); writeDecimals(parts.decimal, parts.decimalPlaces);
if (parts.exponent < 0) { if (parts.exponent < 0) {
writeRaw("e-"); writeRaw("e-");
writePositiveInteger(-parts.exponent); writePositiveInteger(-parts.exponent);
} }
if (parts.exponent > 0) { if (parts.exponent > 0) {
writeRaw('e'); writeRaw('e');
writePositiveInteger(parts.exponent); writePositiveInteger(parts.exponent);
} }
} }
void writeNegativeInteger(UInt value) { void writeNegativeInteger(UInt value) {
writeRaw('-'); writeRaw('-');
writePositiveInteger(value); writePositiveInteger(value);
} }
template <typename T> template <typename T>
void writePositiveInteger(T value) { void writePositiveInteger(T value) {
char buffer[22]; char buffer[22];
char *end = buffer + sizeof(buffer); char *end = buffer + sizeof(buffer);
char *begin = end; char *begin = end;
// write the string in reverse order // write the string in reverse order
do { do {
*--begin = char(value % 10 + '0'); *--begin = char(value % 10 + '0');
value = T(value / 10); value = T(value / 10);
} while (value); } while (value);
// and dump it in the right order // and dump it in the right order
writeRaw(begin, end); writeRaw(begin, end);
} }
void writeDecimals(uint32_t value, int8_t width) { void writeDecimals(uint32_t value, int8_t width) {
// buffer should be big enough for all digits and the dot // buffer should be big enough for all digits and the dot
char buffer[16]; char buffer[16];
char *end = buffer + sizeof(buffer); char *end = buffer + sizeof(buffer);
char *begin = end; char *begin = end;
// write the string in reverse order // write the string in reverse order
while (width--) { while (width--) {
*--begin = char(value % 10 + '0'); *--begin = char(value % 10 + '0');
value /= 10; value /= 10;
} }
*--begin = '.'; *--begin = '.';
// and dump it in the right order // and dump it in the right order
writeRaw(begin, end); writeRaw(begin, end);
} }
void writeRaw(const char *s) { void writeRaw(const char *s) {
_length += _writer.write(reinterpret_cast<const uint8_t *>(s), strlen(s)); _length += _writer.write(reinterpret_cast<const uint8_t *>(s), strlen(s));
} }
void writeRaw(const char *s, size_t n) { void writeRaw(const char *s, size_t n) {
_length += _writer.write(reinterpret_cast<const uint8_t *>(s), n); _length += _writer.write(reinterpret_cast<const uint8_t *>(s), n);
} }
void writeRaw(const char *begin, const char *end) { void writeRaw(const char *begin, const char *end) {
_length += _writer.write(reinterpret_cast<const uint8_t *>(begin), _length += _writer.write(reinterpret_cast<const uint8_t *>(begin),
static_cast<size_t>(end - begin)); static_cast<size_t>(end - begin));
} }
template <size_t N> template <size_t N>
void writeRaw(const char (&s)[N]) { void writeRaw(const char (&s)[N]) {
_length += _writer.write(reinterpret_cast<const uint8_t *>(s), N - 1); _length += _writer.write(reinterpret_cast<const uint8_t *>(s), N - 1);
} }
void writeRaw(char c) { void writeRaw(char c) {
_length += _writer.write(static_cast<uint8_t>(c)); _length += _writer.write(static_cast<uint8_t>(c));
} }
protected: protected:
TWriter _writer; TWriter _writer;
size_t _length; size_t _length;
private: private:
TextFormatter &operator=(const TextFormatter &); // cannot be assigned TextFormatter &operator=(const TextFormatter &); // cannot be assigned
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

132
lib_standalone/ArduinoJson/src/ArduinoJson/Json/Utf16.hpp → lib/ArduinoJson/src/ArduinoJson/Json/Utf16.hpp
View File

@@ -1,65 +1,67 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
#include <stdint.h> // uint16_t, uint32_t #include <stdint.h> // uint16_t, uint32_t
// The high surrogate may be uninitialized if the pair is invalid, // The high surrogate may be uninitialized if the pair is invalid,
// we choose to ignore the problem to reduce the size of the code // we choose to ignore the problem to reduce the size of the code
// Garbage in => Garbage out // Garbage in => Garbage out
#if defined(__GNUC__) #if defined(__GNUC__)
#if __GNUC__ >= 7 #if __GNUC__ >= 7
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif #endif
#endif #endif
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
namespace Utf16 { namespace Utf16 {
inline bool isHighSurrogate(uint16_t codeunit) { inline bool isHighSurrogate(uint16_t codeunit) {
return codeunit >= 0xD800 && codeunit < 0xDC00; return codeunit >= 0xD800 && codeunit < 0xDC00;
} }
inline bool isLowSurrogate(uint16_t codeunit) { inline bool isLowSurrogate(uint16_t codeunit) {
return codeunit >= 0xDC00 && codeunit < 0xE000; return codeunit >= 0xDC00 && codeunit < 0xE000;
} }
class Codepoint { class Codepoint {
public: public:
bool append(uint16_t codeunit) { Codepoint() : _highSurrogate(0) {}
if (isHighSurrogate(codeunit)) {
_highSurrogate = codeunit & 0x3FF; bool append(uint16_t codeunit) {
return false; if (isHighSurrogate(codeunit)) {
} _highSurrogate = codeunit & 0x3FF;
return false;
if (isLowSurrogate(codeunit)) { }
_codepoint =
uint32_t(0x10000 + ((_highSurrogate << 10) | (codeunit & 0x3FF))); if (isLowSurrogate(codeunit)) {
return true; _codepoint =
} uint32_t(0x10000 + ((_highSurrogate << 10) | (codeunit & 0x3FF)));
return true;
_codepoint = codeunit; }
return true;
} _codepoint = codeunit;
return true;
uint32_t value() const { }
return _codepoint;
} uint32_t value() const {
return _codepoint;
private: }
uint16_t _highSurrogate;
uint32_t _codepoint; private:
}; uint16_t _highSurrogate;
} // namespace Utf16 uint32_t _codepoint;
} // namespace ARDUINOJSON_NAMESPACE };
} // namespace Utf16
#if defined(__GNUC__) } // namespace ARDUINOJSON_NAMESPACE
#if __GNUC__ >= 8
#pragma GCC diagnostic pop #if defined(__GNUC__)
#endif #if __GNUC__ >= 8
#endif #pragma GCC diagnostic pop
#endif
#endif

92
lib_standalone/ArduinoJson/src/ArduinoJson/Json/Utf8.hpp → lib/ArduinoJson/src/ArduinoJson/Json/Utf8.hpp
View File

@@ -1,46 +1,46 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
namespace Utf8 { namespace Utf8 {
template <typename TStringBuilder> template <typename TStringBuilder>
inline void encodeCodepoint(uint32_t codepoint32, TStringBuilder& str) { inline void encodeCodepoint(uint32_t codepoint32, TStringBuilder& str) {
// this function was optimize for code size on AVR // this function was optimize for code size on AVR
// a buffer to store the string in reverse // a buffer to store the string in reverse
char buf[5]; char buf[5];
char* p = buf; char* p = buf;
*(p++) = 0; *(p++) = 0;
if (codepoint32 < 0x80) { if (codepoint32 < 0x80) {
*(p++) = char((codepoint32)); *(p++) = char((codepoint32));
} else { } else {
*(p++) = char((codepoint32 | 0x80) & 0xBF); *(p++) = char((codepoint32 | 0x80) & 0xBF);
uint16_t codepoint16 = uint16_t(codepoint32 >> 6); uint16_t codepoint16 = uint16_t(codepoint32 >> 6);
if (codepoint16 < 0x20) { // 0x800 if (codepoint16 < 0x20) { // 0x800
*(p++) = char(codepoint16 | 0xC0); *(p++) = char(codepoint16 | 0xC0);
} else { } else {
*(p++) = char((codepoint16 | 0x80) & 0xBF); *(p++) = char((codepoint16 | 0x80) & 0xBF);
codepoint16 = uint16_t(codepoint16 >> 6); codepoint16 = uint16_t(codepoint16 >> 6);
if (codepoint16 < 0x10) { // 0x10000 if (codepoint16 < 0x10) { // 0x10000
*(p++) = char(codepoint16 | 0xE0); *(p++) = char(codepoint16 | 0xE0);
} else { } else {
*(p++) = char((codepoint16 | 0x80) & 0xBF); *(p++) = char((codepoint16 | 0x80) & 0xBF);
codepoint16 = uint16_t(codepoint16 >> 6); codepoint16 = uint16_t(codepoint16 >> 6);
*(p++) = char(codepoint16 | 0xF0); *(p++) = char(codepoint16 | 0xF0);
} }
} }
} }
while (*(--p)) { while (*(--p)) {
str.append(*p); str.append(*p);
} }
} }
} // namespace Utf8 } // namespace Utf8
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

96
lib_standalone/ArduinoJson/src/ArduinoJson/Memory/Alignment.hpp → lib/ArduinoJson/src/ArduinoJson/Memory/Alignment.hpp
View File

@@ -1,36 +1,60 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
#include <stddef.h> // size_t #include <stddef.h> // size_t
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
inline bool isAligned(void *ptr) { #if ARDUINOJSON_ENABLE_ALIGNMENT
const size_t mask = sizeof(void *) - 1;
size_t addr = reinterpret_cast<size_t>(ptr); inline bool isAligned(size_t value) {
return (addr & mask) == 0; const size_t mask = sizeof(void *) - 1;
} size_t addr = value;
return (addr & mask) == 0;
inline size_t addPadding(size_t bytes) { }
const size_t mask = sizeof(void *) - 1;
return (bytes + mask) & ~mask; inline size_t addPadding(size_t bytes) {
} const size_t mask = sizeof(void *) - 1;
return (bytes + mask) & ~mask;
template <typename T> }
inline T *addPadding(T *p) {
size_t address = addPadding(reinterpret_cast<size_t>(p)); template <size_t bytes>
return reinterpret_cast<T *>(address); struct AddPadding {
} static const size_t mask = sizeof(void *) - 1;
static const size_t value = (bytes + mask) & ~mask;
template <size_t bytes> };
struct AddPadding {
static const size_t mask = sizeof(void *) - 1; #else
static const size_t value = (bytes + mask) & ~mask;
}; inline bool isAligned(size_t) {
return true;
} // namespace ARDUINOJSON_NAMESPACE }
inline size_t addPadding(size_t bytes) {
return bytes;
}
template <size_t bytes>
struct AddPadding {
static const size_t value = bytes;
};
#endif
template <typename T>
inline bool isAligned(T *ptr) {
return isAligned(reinterpret_cast<size_t>(ptr));
}
template <typename T>
inline T *addPadding(T *p) {
size_t address = addPadding(reinterpret_cast<size_t>(p));
return reinterpret_cast<T *>(address);
}
} // namespace ARDUINOJSON_NAMESPACE

361
lib_standalone/ArduinoJson/src/ArduinoJson/Memory/MemoryPool.hpp → lib/ArduinoJson/src/ArduinoJson/Memory/MemoryPool.hpp
View File

@@ -1,161 +1,200 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Memory/Alignment.hpp> #include <ArduinoJson/Memory/Alignment.hpp>
#include <ArduinoJson/Memory/StringSlot.hpp> #include <ArduinoJson/Memory/StringSlot.hpp>
#include <ArduinoJson/Polyfills/assert.hpp> #include <ArduinoJson/Polyfills/assert.hpp>
#include <ArduinoJson/Polyfills/mpl/max.hpp> #include <ArduinoJson/Polyfills/mpl/max.hpp>
#include <ArduinoJson/Variant/VariantSlot.hpp> #include <ArduinoJson/Variant/VariantSlot.hpp>
#include <string.h> // memmove #include <string.h> // memmove
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
// _begin _end // _begin _end
// v v // v v
// +-------------+--------------+--------------+ // +-------------+--------------+--------------+
// | strings... | (free) | ...variants | // | strings... | (free) | ...variants |
// +-------------+--------------+--------------+ // +-------------+--------------+--------------+
// ^ ^ // ^ ^
// _left _right // _left _right
class MemoryPool { class MemoryPool {
public: public:
MemoryPool(char* buf, size_t capa) MemoryPool(char* buf, size_t capa)
: _begin(buf), : _begin(buf),
_left(buf), _left(buf),
_right(buf ? buf + capa : 0), _right(buf ? buf + capa : 0),
_end(buf ? buf + capa : 0) { _end(buf ? buf + capa : 0) {
ARDUINOJSON_ASSERT(isAligned(_begin)); ARDUINOJSON_ASSERT(isAligned(_begin));
ARDUINOJSON_ASSERT(isAligned(_right)); ARDUINOJSON_ASSERT(isAligned(_right));
ARDUINOJSON_ASSERT(isAligned(_end)); ARDUINOJSON_ASSERT(isAligned(_end));
} }
void* buffer() { void* buffer() {
return _begin; return _begin;
} }
// Gets the capacity of the memoryPool in bytes // Gets the capacity of the memoryPool in bytes
size_t capacity() const { size_t capacity() const {
return size_t(_end - _begin); return size_t(_end - _begin);
} }
size_t size() const { size_t size() const {
return size_t(_left - _begin + _end - _right); return size_t(_left - _begin + _end - _right);
} }
VariantSlot* allocVariant() { VariantSlot* allocVariant() {
return allocRight<VariantSlot>(); return allocRight<VariantSlot>();
} }
char* allocFrozenString(size_t n) { template <typename TAdaptedString>
if (!canAlloc(n)) const char* saveString(const TAdaptedString& str) {
return 0; if (str.isNull())
char* s = _left; return 0;
_left += n;
checkInvariants(); #if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION
return s; const char* existingCopy = findString(str.begin());
} if (existingCopy)
return existingCopy;
StringSlot allocExpandableString() { #endif
StringSlot s;
s.value = _left; size_t n = str.size();
s.size = size_t(_right - _left);
_left = _right; char* newCopy = allocString(n + 1);
checkInvariants(); if (newCopy) {
return s; str.copyTo(newCopy, n);
} newCopy[n] = 0; // force null-terminator
}
void freezeString(StringSlot& s, size_t newSize) { return newCopy;
_left -= (s.size - newSize); }
s.size = newSize;
checkInvariants(); void getFreeZone(char** zoneStart, size_t* zoneSize) const {
} *zoneStart = _left;
*zoneSize = size_t(_right - _left);
void reclaimLastString(const char* s) { }
_left = const_cast<char*>(s);
} const char* saveStringFromFreeZone(size_t len) {
#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION
void clear() { const char* dup = findString(_left);
_left = _begin; if (dup)
_right = _end; return dup;
} #endif
bool canAlloc(size_t bytes) const { const char* str = _left;
return _left + bytes <= _right; _left += len;
} checkInvariants();
return str;
bool owns(void* p) const { }
return _begin <= p && p < _end;
} void clear() {
_left = _begin;
template <typename T> _right = _end;
T* allocRight() { }
return reinterpret_cast<T*>(allocRight(sizeof(T)));
} bool canAlloc(size_t bytes) const {
return _left + bytes <= _right;
void* allocRight(size_t bytes) { }
if (!canAlloc(bytes))
return 0; bool owns(void* p) const {
_right -= bytes; return _begin <= p && p < _end;
return _right; }
}
// Workaround for missing placement new
// Workaround for missing placement new void* operator new(size_t, void* p) {
void* operator new(size_t, void* p) { return p;
return p; }
}
// Squash the free space between strings and variants
// Squash the free space between strings and variants //
// // _begin _end
// _begin _end // v v
// v v // +-------------+--------------+
// +-------------+--------------+ // | strings... | ...variants |
// | strings... | ...variants | // +-------------+--------------+
// +-------------+--------------+ // ^
// ^ // _left _right
// _left _right //
// // This funcion is called before a realloc.
// This funcion is called before a realloc. ptrdiff_t squash() {
ptrdiff_t squash() { char* new_right = addPadding(_left);
char* new_right = addPadding(_left); if (new_right >= _right)
if (new_right >= _right) return 0;
return 0;
size_t right_size = static_cast<size_t>(_end - _right);
size_t right_size = static_cast<size_t>(_end - _right); memmove(new_right, _right, right_size);
memmove(new_right, _right, right_size);
ptrdiff_t bytes_reclaimed = _right - new_right;
ptrdiff_t bytes_reclaimed = _right - new_right; _right = new_right;
_right = new_right; _end = new_right + right_size;
_end = new_right + right_size; return bytes_reclaimed;
return bytes_reclaimed; }
}
// Move all pointers together
// Move all pointers together // This funcion is called after a realloc.
// This funcion is called after a realloc. void movePointers(ptrdiff_t offset) {
void movePointers(ptrdiff_t offset) { _begin += offset;
_begin += offset; _left += offset;
_left += offset; _right += offset;
_right += offset; _end += offset;
_end += offset; }
}
private:
private: StringSlot* allocStringSlot() {
StringSlot* allocStringSlot() { return allocRight<StringSlot>();
return allocRight<StringSlot>(); }
}
void checkInvariants() {
void checkInvariants() { ARDUINOJSON_ASSERT(_begin <= _left);
ARDUINOJSON_ASSERT(_begin <= _left); ARDUINOJSON_ASSERT(_left <= _right);
ARDUINOJSON_ASSERT(_left <= _right); ARDUINOJSON_ASSERT(_right <= _end);
ARDUINOJSON_ASSERT(_right <= _end); ARDUINOJSON_ASSERT(isAligned(_right));
ARDUINOJSON_ASSERT(isAligned(_right)); }
}
#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION
char *_begin, *_left, *_right, *_end; template <typename TIterator>
}; const char* findString(TIterator str) {
for (char* next = _begin; next < _left; ++next) {
} // namespace ARDUINOJSON_NAMESPACE char* begin = next;
// try to match
for (TIterator it = str; *it == *next; ++it) {
if (*next++ == 0)
return begin;
}
// jump to next terminator
while (*next) ++next;
}
return 0;
}
#endif
char* allocString(size_t n) {
if (!canAlloc(n))
return 0;
char* s = _left;
_left += n;
checkInvariants();
return s;
}
template <typename T>
T* allocRight() {
return reinterpret_cast<T*>(allocRight(sizeof(T)));
}
void* allocRight(size_t bytes) {
if (!canAlloc(bytes))
return 0;
_right -= bytes;
return _right;
}
char *_begin, *_left, *_right, *_end;
};
} // namespace ARDUINOJSON_NAMESPACE

38
lib_standalone/ArduinoJson/src/ArduinoJson/Memory/StringSlot.hpp → lib/ArduinoJson/src/ArduinoJson/Memory/StringSlot.hpp
View File

@@ -1,19 +1,19 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <stddef.h> // for size_t #include <stddef.h> // for size_t
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
#define JSON_STRING_SIZE(SIZE) (SIZE) #define JSON_STRING_SIZE(SIZE) (SIZE + 1)
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
struct StringSlot { struct StringSlot {
char *value; char *value;
size_t size; size_t size;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

136
lib_standalone/ArduinoJson/src/ArduinoJson/Misc/SerializedValue.hpp → lib/ArduinoJson/src/ArduinoJson/Misc/SerializedValue.hpp
View File

@@ -1,68 +1,68 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Strings/StringAdapters.hpp> #include <ArduinoJson/Strings/StringAdapters.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
// A special type of data that can be used to insert pregenerated JSON portions. // A special type of data that can be used to insert pregenerated JSON portions.
template <typename T> template <typename T>
class SerializedValue { class SerializedValue {
public: public:
explicit SerializedValue(T str) : _str(str) {} explicit SerializedValue(T str) : _str(str) {}
operator T() const { operator T() const {
return _str; return _str;
} }
const char* data() const { const char* data() const {
return _str.c_str(); return _str.c_str();
} }
size_t size() const { size_t size() const {
// CAUTION: the old Arduino String doesn't have size() // CAUTION: the old Arduino String doesn't have size()
return _str.length(); return _str.length();
} }
private: private:
T _str; T _str;
}; };
template <typename TChar> template <typename TChar>
class SerializedValue<TChar*> { class SerializedValue<TChar*> {
public: public:
explicit SerializedValue(TChar* p, size_t n) : _data(p), _size(n) {} explicit SerializedValue(TChar* p, size_t n) : _data(p), _size(n) {}
operator TChar*() const { operator TChar*() const {
return _data; return _data;
} }
TChar* data() const { TChar* data() const {
return _data; return _data;
} }
size_t size() const { size_t size() const {
return _size; return _size;
} }
private: private:
TChar* _data; TChar* _data;
size_t _size; size_t _size;
}; };
template <typename T> template <typename T>
inline SerializedValue<T> serialized(T str) { inline SerializedValue<T> serialized(T str) {
return SerializedValue<T>(str); return SerializedValue<T>(str);
} }
template <typename TChar> template <typename TChar>
inline SerializedValue<TChar*> serialized(TChar* p) { inline SerializedValue<TChar*> serialized(TChar* p) {
return SerializedValue<TChar*>(p, adaptString(p).size()); return SerializedValue<TChar*>(p, adaptString(p).size());
} }
template <typename TChar> template <typename TChar>
inline SerializedValue<TChar*> serialized(TChar* p, size_t n) { inline SerializedValue<TChar*> serialized(TChar* p, size_t n) {
return SerializedValue<TChar*>(p, n); return SerializedValue<TChar*>(p, n);
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

42
lib_standalone/ArduinoJson/src/ArduinoJson/Misc/Visitable.hpp → lib/ArduinoJson/src/ArduinoJson/Misc/Visitable.hpp
View File

@@ -1,21 +1,21 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Polyfills/type_traits.hpp> #include <ArduinoJson/Polyfills/type_traits.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
struct Visitable { struct Visitable {
// template<Visitor> // template<Visitor>
// void accept(Visitor&) const; // void accept(Visitor&) const;
}; };
template <typename T> template <typename T>
struct IsVisitable : is_base_of<Visitable, T> {}; struct IsVisitable : is_base_of<Visitable, T> {};
template <typename T> template <typename T>
struct IsVisitable<T&> : IsVisitable<T> {}; struct IsVisitable<T&> : IsVisitable<T> {};
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

756
lib_standalone/ArduinoJson/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp → lib/ArduinoJson/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp
View File

@@ -1,374 +1,382 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Deserialization/deserialize.hpp> #include <ArduinoJson/Deserialization/deserialize.hpp>
#include <ArduinoJson/Memory/MemoryPool.hpp> #include <ArduinoJson/Memory/MemoryPool.hpp>
#include <ArduinoJson/MsgPack/endianess.hpp> #include <ArduinoJson/MsgPack/endianess.hpp>
#include <ArduinoJson/MsgPack/ieee754.hpp> #include <ArduinoJson/MsgPack/ieee754.hpp>
#include <ArduinoJson/Polyfills/type_traits.hpp> #include <ArduinoJson/Polyfills/type_traits.hpp>
#include <ArduinoJson/Variant/VariantData.hpp> #include <ArduinoJson/Variant/VariantData.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TReader, typename TStringStorage> template <typename TReader, typename TStringStorage>
class MsgPackDeserializer { class MsgPackDeserializer {
typedef typename remove_reference<TStringStorage>::type::StringBuilder public:
StringBuilder; MsgPackDeserializer(MemoryPool &pool, TReader reader,
TStringStorage stringStorage)
public: : _pool(&pool),
MsgPackDeserializer(MemoryPool &pool, TReader reader, _reader(reader),
TStringStorage stringStorage) _stringStorage(stringStorage),
: _pool(&pool), _reader(reader), _stringStorage(stringStorage) {} _error(DeserializationError::Ok) {}
DeserializationError parse(VariantData &variant, AllowAllFilter, // TODO: add support for filter
NestingLimit nestingLimit) { DeserializationError parse(VariantData &variant, AllowAllFilter,
return parse(variant, nestingLimit); NestingLimit nestingLimit) {
} parseVariant(variant, nestingLimit);
return _error;
DeserializationError parse(VariantData &variant, NestingLimit nestingLimit) { }
uint8_t code;
if (!readByte(code)) private:
return DeserializationError::IncompleteInput; bool parseVariant(VariantData &variant, NestingLimit nestingLimit) {
uint8_t code;
if ((code & 0x80) == 0) { if (!readByte(code)) {
variant.setUnsignedInteger(code); _error = DeserializationError::IncompleteInput;
return DeserializationError::Ok; return false;
} }
if ((code & 0xe0) == 0xe0) { if ((code & 0x80) == 0) {
variant.setSignedInteger(static_cast<int8_t>(code)); variant.setUnsignedInteger(code);
return DeserializationError::Ok; return true;
} }
if ((code & 0xe0) == 0xa0) { if ((code & 0xe0) == 0xe0) {
return readString(variant, code & 0x1f); variant.setSignedInteger(static_cast<int8_t>(code));
} return true;
}
if ((code & 0xf0) == 0x90) {
return readArray(variant.toArray(), code & 0x0F, nestingLimit); if ((code & 0xe0) == 0xa0) {
} return readString(variant, code & 0x1f);
}
if ((code & 0xf0) == 0x80) {
return readObject(variant.toObject(), code & 0x0F, nestingLimit); if ((code & 0xf0) == 0x90) {
} return readArray(variant.toArray(), code & 0x0F, nestingLimit);
}
switch (code) {
case 0xc0: if ((code & 0xf0) == 0x80) {
// already null return readObject(variant.toObject(), code & 0x0F, nestingLimit);
return DeserializationError::Ok; }
case 0xc2: switch (code) {
variant.setBoolean(false); case 0xc0:
return DeserializationError::Ok; // already null
return true;
case 0xc3:
variant.setBoolean(true); case 0xc2:
return DeserializationError::Ok; variant.setBoolean(false);
return true;
case 0xcc:
return readInteger<uint8_t>(variant); case 0xc3:
variant.setBoolean(true);
case 0xcd: return true;
return readInteger<uint16_t>(variant);
case 0xcc:
case 0xce: return readInteger<uint8_t>(variant);
return readInteger<uint32_t>(variant);
case 0xcd:
case 0xcf: return readInteger<uint16_t>(variant);
#if ARDUINOJSON_USE_LONG_LONG
return readInteger<uint64_t>(variant); case 0xce:
#else return readInteger<uint32_t>(variant);
return DeserializationError::NotSupported;
#endif #if ARDUINOJSON_USE_LONG_LONG
case 0xcf:
case 0xd0: return readInteger<uint64_t>(variant);
return readInteger<int8_t>(variant); #endif
case 0xd1: case 0xd0:
return readInteger<int16_t>(variant); return readInteger<int8_t>(variant);
case 0xd2: case 0xd1:
return readInteger<int32_t>(variant); return readInteger<int16_t>(variant);
case 0xd3: case 0xd2:
#if ARDUINOJSON_USE_LONG_LONG return readInteger<int32_t>(variant);
return readInteger<int64_t>(variant);
#else #if ARDUINOJSON_USE_LONG_LONG
return DeserializationError::NotSupported; case 0xd3:
#endif return readInteger<int64_t>(variant);
#endif
case 0xca:
return readFloat<float>(variant); case 0xca:
return readFloat<float>(variant);
case 0xcb:
return readDouble<double>(variant); case 0xcb:
return readDouble<double>(variant);
case 0xd9:
return readString<uint8_t>(variant); case 0xd9:
return readString<uint8_t>(variant);
case 0xda:
return readString<uint16_t>(variant); case 0xda:
return readString<uint16_t>(variant);
case 0xdb:
return readString<uint32_t>(variant); case 0xdb:
return readString<uint32_t>(variant);
case 0xdc:
return readArray<uint16_t>(variant.toArray(), nestingLimit); case 0xdc:
return readArray<uint16_t>(variant.toArray(), nestingLimit);
case 0xdd:
return readArray<uint32_t>(variant.toArray(), nestingLimit); case 0xdd:
return readArray<uint32_t>(variant.toArray(), nestingLimit);
case 0xde:
return readObject<uint16_t>(variant.toObject(), nestingLimit); case 0xde:
return readObject<uint16_t>(variant.toObject(), nestingLimit);
case 0xdf:
return readObject<uint32_t>(variant.toObject(), nestingLimit); case 0xdf:
return readObject<uint32_t>(variant.toObject(), nestingLimit);
default:
return DeserializationError::NotSupported; default:
} _error = DeserializationError::NotSupported;
} return false;
}
private: }
// Prevent VS warning "assignment operator could not be generated"
MsgPackDeserializer &operator=(const MsgPackDeserializer &); private:
// Prevent VS warning "assignment operator could not be generated"
bool readByte(uint8_t &value) { MsgPackDeserializer &operator=(const MsgPackDeserializer &);
int c = _reader.read();
if (c < 0) bool readByte(uint8_t &value) {
return false; int c = _reader.read();
value = static_cast<uint8_t>(c); if (c < 0) {
return true; _error = DeserializationError::IncompleteInput;
} return false;
}
bool readBytes(uint8_t *p, size_t n) { value = static_cast<uint8_t>(c);
return _reader.readBytes(reinterpret_cast<char *>(p), n) == n; return true;
} }
template <typename T> bool readBytes(uint8_t *p, size_t n) {
bool readBytes(T &value) { if (_reader.readBytes(reinterpret_cast<char *>(p), n) == n)
return readBytes(reinterpret_cast<uint8_t *>(&value), sizeof(value)); return true;
} _error = DeserializationError::IncompleteInput;
return false;
template <typename T> }
T readInteger() {
T value; template <typename T>
readBytes(value); bool readBytes(T &value) {
fixEndianess(value); return readBytes(reinterpret_cast<uint8_t *>(&value), sizeof(value));
return value; }
}
template <typename T>
template <typename T> bool readInteger(T &value) {
bool readInteger(T &value) { if (!readBytes(value))
if (!readBytes(value)) return false;
return false; fixEndianess(value);
fixEndianess(value); return true;
return true; }
}
template <typename T>
template <typename T> bool readInteger(VariantData &variant) {
DeserializationError readInteger(VariantData &variant) { T value;
T value; if (!readInteger(value))
if (!readInteger(value)) return false;
return DeserializationError::IncompleteInput; variant.setInteger(value);
variant.setInteger(value); return true;
return DeserializationError::Ok; }
}
template <typename T>
template <typename T> typename enable_if<sizeof(T) == 4, bool>::type readFloat(
typename enable_if<sizeof(T) == 4, DeserializationError>::type readFloat( VariantData &variant) {
VariantData &variant) { T value;
T value; if (!readBytes(value))
if (!readBytes(value)) return false;
return DeserializationError::IncompleteInput; fixEndianess(value);
fixEndianess(value); variant.setFloat(value);
variant.setFloat(value); return true;
return DeserializationError::Ok; }
}
template <typename T>
template <typename T> typename enable_if<sizeof(T) == 8, bool>::type readDouble(
typename enable_if<sizeof(T) == 8, DeserializationError>::type readDouble( VariantData &variant) {
VariantData &variant) { T value;
T value; if (!readBytes(value))
if (!readBytes(value)) return false;
return DeserializationError::IncompleteInput; fixEndianess(value);
fixEndianess(value); variant.setFloat(value);
variant.setFloat(value); return true;
return DeserializationError::Ok; }
}
template <typename T>
template <typename T> typename enable_if<sizeof(T) == 4, bool>::type readDouble(
typename enable_if<sizeof(T) == 4, DeserializationError>::type readDouble( VariantData &variant) {
VariantData &variant) { uint8_t i[8]; // input is 8 bytes
uint8_t i[8]; // input is 8 bytes T value; // output is 4 bytes
T value; // output is 4 bytes uint8_t *o = reinterpret_cast<uint8_t *>(&value);
uint8_t *o = reinterpret_cast<uint8_t *>(&value); if (!readBytes(i, 8))
if (!readBytes(i, 8)) return false;
return DeserializationError::IncompleteInput; doubleToFloat(i, o);
doubleToFloat(i, o); fixEndianess(value);
fixEndianess(value); variant.setFloat(value);
variant.setFloat(value); return true;
return DeserializationError::Ok; }
}
template <typename T>
template <typename T> bool readString(VariantData &variant) {
DeserializationError readString(VariantData &variant) { T size;
T size; if (!readInteger(size))
if (!readInteger(size)) return false;
return DeserializationError::IncompleteInput; return readString(variant, size);
return readString(variant, size); }
}
template <typename T>
template <typename T> bool readString(const char *&str) {
DeserializationError readString(const char *&str) { T size;
T size; if (!readInteger(size))
if (!readInteger(size)) return false;
return DeserializationError::IncompleteInput; return readString(str, size);
return readString(str, size); }
}
bool readString(VariantData &variant, size_t n) {
DeserializationError readString(VariantData &variant, size_t n) { const char *s = 0; // <- mute "maybe-uninitialized" (+4 bytes on AVR)
const char *s = 0; // <- mute "maybe-uninitialized" (+4 bytes on AVR) if (!readString(s, n))
DeserializationError err = readString(s, n); return false;
if (!err) variant.setString(make_not_null(s),
variant.setOwnedString(make_not_null(s)); typename TStringStorage::storage_policy());
return err; return true;
} }
DeserializationError readString(const char *&result, size_t n) { bool readString(const char *&result, size_t n) {
StringBuilder builder = _stringStorage.startString(); _stringStorage.startString(_pool);
for (; n; --n) { for (; n; --n) {
uint8_t c; uint8_t c;
if (!readBytes(c)) if (!readBytes(c))
return DeserializationError::IncompleteInput; return false;
builder.append(static_cast<char>(c)); _stringStorage.append(static_cast<char>(c));
} }
result = builder.complete(); _stringStorage.append('\0');
if (!result) if (!_stringStorage.isValid()) {
return DeserializationError::NoMemory; _error = DeserializationError::NoMemory;
return DeserializationError::Ok; return false;
} }
template <typename TSize> result = _stringStorage.save(_pool);
DeserializationError readArray(CollectionData &array, return true;
NestingLimit nestingLimit) { }
TSize size;
if (!readInteger(size)) template <typename TSize>
return DeserializationError::IncompleteInput; bool readArray(CollectionData &array, NestingLimit nestingLimit) {
return readArray(array, size, nestingLimit); TSize size;
} if (!readInteger(size))
return false;
DeserializationError readArray(CollectionData &array, size_t n, return readArray(array, size, nestingLimit);
NestingLimit nestingLimit) { }
if (nestingLimit.reached())
return DeserializationError::TooDeep; bool readArray(CollectionData &array, size_t n, NestingLimit nestingLimit) {
if (nestingLimit.reached()) {
for (; n; --n) { _error = DeserializationError::TooDeep;
VariantData *value = array.addElement(_pool); return false;
if (!value) }
return DeserializationError::NoMemory;
for (; n; --n) {
DeserializationError err = parse(*value, nestingLimit.decrement()); VariantData *value = array.addElement(_pool);
if (err) if (!value) {
return err; _error = DeserializationError::NoMemory;
} return false;
}
return DeserializationError::Ok;
} if (!parseVariant(*value, nestingLimit.decrement()))
return false;
template <typename TSize> }
DeserializationError readObject(CollectionData &object,
NestingLimit nestingLimit) { return true;
TSize size; }
if (!readInteger(size))
return DeserializationError::IncompleteInput; template <typename TSize>
return readObject(object, size, nestingLimit); bool readObject(CollectionData &object, NestingLimit nestingLimit) {
} TSize size;
if (!readInteger(size))
DeserializationError readObject(CollectionData &object, size_t n, return false;
NestingLimit nestingLimit) { return readObject(object, size, nestingLimit);
if (nestingLimit.reached()) }
return DeserializationError::TooDeep;
bool readObject(CollectionData &object, size_t n, NestingLimit nestingLimit) {
for (; n; --n) { if (nestingLimit.reached()) {
VariantSlot *slot = object.addSlot(_pool); _error = DeserializationError::TooDeep;
if (!slot) return false;
return DeserializationError::NoMemory; }
const char *key = 0; // <- mute "maybe-uninitialized" (+4 bytes on AVR) for (; n; --n) {
DeserializationError err = parseKey(key); VariantSlot *slot = object.addSlot(_pool);
if (err) if (!slot) {
return err; _error = DeserializationError::NoMemory;
slot->setOwnedKey(make_not_null(key)); return false;
}
err = parse(*slot->data(), nestingLimit.decrement());
if (err) const char *key = 0; // <- mute "maybe-uninitialized" (+4 bytes on AVR)
return err; if (!parseKey(key))
} return false;
return DeserializationError::Ok; slot->setKey(key, typename TStringStorage::storage_policy());
}
if (!parseVariant(*slot->data(), nestingLimit.decrement()))
DeserializationError parseKey(const char *&key) { return false;
uint8_t code; }
if (!readByte(code))
return DeserializationError::IncompleteInput; return true;
}
if ((code & 0xe0) == 0xa0)
return readString(key, code & 0x1f); bool parseKey(const char *&key) {
uint8_t code;
switch (code) { if (!readByte(code))
case 0xd9: return false;
return readString<uint8_t>(key);
if ((code & 0xe0) == 0xa0)
case 0xda: return readString(key, code & 0x1f);
return readString<uint16_t>(key);
switch (code) {
case 0xdb: case 0xd9:
return readString<uint32_t>(key); return readString<uint8_t>(key);
default: case 0xda:
return DeserializationError::NotSupported; return readString<uint16_t>(key);
}
} case 0xdb:
return readString<uint32_t>(key);
MemoryPool *_pool;
TReader _reader; default:
TStringStorage _stringStorage; _error = DeserializationError::NotSupported;
}; return false;
}
template <typename TInput> }
DeserializationError deserializeMsgPack(
JsonDocument &doc, const TInput &input, MemoryPool *_pool;
NestingLimit nestingLimit = NestingLimit()) { TReader _reader;
return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, TStringStorage _stringStorage;
AllowAllFilter()); DeserializationError _error;
} };
template <typename TInput> template <typename TInput>
DeserializationError deserializeMsgPack( DeserializationError deserializeMsgPack(
JsonDocument &doc, TInput *input, JsonDocument &doc, const TInput &input,
NestingLimit nestingLimit = NestingLimit()) { NestingLimit nestingLimit = NestingLimit()) {
return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, return deserialize<MsgPackDeserializer>(doc, input, nestingLimit,
AllowAllFilter()); AllowAllFilter());
} }
template <typename TInput> template <typename TInput>
DeserializationError deserializeMsgPack( DeserializationError deserializeMsgPack(
JsonDocument &doc, TInput *input, size_t inputSize, JsonDocument &doc, TInput *input,
NestingLimit nestingLimit = NestingLimit()) { NestingLimit nestingLimit = NestingLimit()) {
return deserialize<MsgPackDeserializer>(doc, input, inputSize, nestingLimit, return deserialize<MsgPackDeserializer>(doc, input, nestingLimit,
AllowAllFilter()); AllowAllFilter());
} }
template <typename TInput> template <typename TInput>
DeserializationError deserializeMsgPack( DeserializationError deserializeMsgPack(
JsonDocument &doc, TInput &input, JsonDocument &doc, TInput *input, size_t inputSize,
NestingLimit nestingLimit = NestingLimit()) { NestingLimit nestingLimit = NestingLimit()) {
return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, return deserialize<MsgPackDeserializer>(doc, input, inputSize, nestingLimit,
AllowAllFilter()); AllowAllFilter());
} }
} // namespace ARDUINOJSON_NAMESPACE
template <typename TInput>
DeserializationError deserializeMsgPack(
JsonDocument &doc, TInput &input,
NestingLimit nestingLimit = NestingLimit()) {
return deserialize<MsgPackDeserializer>(doc, input, nestingLimit,
AllowAllFilter());
}
} // namespace ARDUINOJSON_NAMESPACE

380
lib_standalone/ArduinoJson/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp → lib/ArduinoJson/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp
View File

@@ -1,187 +1,193 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/MsgPack/endianess.hpp> #include <ArduinoJson/MsgPack/endianess.hpp>
#include <ArduinoJson/Polyfills/assert.hpp> #include <ArduinoJson/Polyfills/assert.hpp>
#include <ArduinoJson/Polyfills/type_traits.hpp> #include <ArduinoJson/Polyfills/type_traits.hpp>
#include <ArduinoJson/Serialization/measure.hpp> #include <ArduinoJson/Serialization/measure.hpp>
#include <ArduinoJson/Serialization/serialize.hpp> #include <ArduinoJson/Serialization/serialize.hpp>
#include <ArduinoJson/Variant/VariantData.hpp> #include <ArduinoJson/Variant/VariantData.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TWriter> template <typename TWriter>
class MsgPackSerializer { class MsgPackSerializer {
public: public:
MsgPackSerializer(TWriter writer) : _writer(writer), _bytesWritten(0) {} MsgPackSerializer(TWriter writer) : _writer(writer), _bytesWritten(0) {}
template <typename T> template <typename T>
typename enable_if<sizeof(T) == 4>::type visitFloat(T value32) { typename enable_if<sizeof(T) == 4>::type visitFloat(T value32) {
writeByte(0xCA); writeByte(0xCA);
writeInteger(value32); writeInteger(value32);
} }
template <typename T> template <typename T>
ARDUINOJSON_NO_SANITIZE("float-cast-overflow") ARDUINOJSON_NO_SANITIZE("float-cast-overflow")
typename enable_if<sizeof(T) == 8>::type visitFloat(T value64) { typename enable_if<sizeof(T) == 8>::type visitFloat(T value64) {
float value32 = float(value64); float value32 = float(value64);
if (value32 == value64) { if (value32 == value64) {
writeByte(0xCA); writeByte(0xCA);
writeInteger(value32); writeInteger(value32);
} else { } else {
writeByte(0xCB); writeByte(0xCB);
writeInteger(value64); writeInteger(value64);
} }
} }
void visitArray(const CollectionData& array) { void visitArray(const CollectionData& array) {
size_t n = array.size(); size_t n = array.size();
if (n < 0x10) { if (n < 0x10) {
writeByte(uint8_t(0x90 + array.size())); writeByte(uint8_t(0x90 + array.size()));
} else if (n < 0x10000) { } else if (n < 0x10000) {
writeByte(0xDC); writeByte(0xDC);
writeInteger(uint16_t(n)); writeInteger(uint16_t(n));
} else { } else {
writeByte(0xDD); writeByte(0xDD);
writeInteger(uint32_t(n)); writeInteger(uint32_t(n));
} }
for (VariantSlot* slot = array.head(); slot; slot = slot->next()) { for (VariantSlot* slot = array.head(); slot; slot = slot->next()) {
slot->data()->accept(*this); slot->data()->accept(*this);
} }
} }
void visitObject(const CollectionData& object) { void visitObject(const CollectionData& object) {
size_t n = object.size(); size_t n = object.size();
if (n < 0x10) { if (n < 0x10) {
writeByte(uint8_t(0x80 + n)); writeByte(uint8_t(0x80 + n));
} else if (n < 0x10000) { } else if (n < 0x10000) {
writeByte(0xDE); writeByte(0xDE);
writeInteger(uint16_t(n)); writeInteger(uint16_t(n));
} else { } else {
writeByte(0xDF); writeByte(0xDF);
writeInteger(uint32_t(n)); writeInteger(uint32_t(n));
} }
for (VariantSlot* slot = object.head(); slot; slot = slot->next()) { for (VariantSlot* slot = object.head(); slot; slot = slot->next()) {
visitString(slot->key()); visitString(slot->key());
slot->data()->accept(*this); slot->data()->accept(*this);
} }
} }
void visitString(const char* value) { void visitString(const char* value) {
ARDUINOJSON_ASSERT(value != NULL); ARDUINOJSON_ASSERT(value != NULL);
size_t n = strlen(value); size_t n = strlen(value);
if (n < 0x20) { if (n < 0x20) {
writeByte(uint8_t(0xA0 + n)); writeByte(uint8_t(0xA0 + n));
} else if (n < 0x100) { } else if (n < 0x100) {
writeByte(0xD9); writeByte(0xD9);
writeInteger(uint8_t(n)); writeInteger(uint8_t(n));
} else if (n < 0x10000) { } else if (n < 0x10000) {
writeByte(0xDA); writeByte(0xDA);
writeInteger(uint16_t(n)); writeInteger(uint16_t(n));
} else { } else {
writeByte(0xDB); writeByte(0xDB);
writeInteger(uint32_t(n)); writeInteger(uint32_t(n));
} }
writeBytes(reinterpret_cast<const uint8_t*>(value), n); writeBytes(reinterpret_cast<const uint8_t*>(value), n);
} }
void visitRawJson(const char* data, size_t size) { void visitRawJson(const char* data, size_t size) {
writeBytes(reinterpret_cast<const uint8_t*>(data), size); writeBytes(reinterpret_cast<const uint8_t*>(data), size);
} }
void visitNegativeInteger(UInt value) { void visitNegativeInteger(UInt value) {
UInt negated = UInt(~value + 1); UInt negated = UInt(~value + 1);
if (value <= 0x20) { if (value <= 0x20) {
writeInteger(int8_t(negated)); writeInteger(int8_t(negated));
} else if (value <= 0x80) { } else if (value <= 0x80) {
writeByte(0xD0); writeByte(0xD0);
writeInteger(int8_t(negated)); writeInteger(int8_t(negated));
} else if (value <= 0x8000) { } else if (value <= 0x8000) {
writeByte(0xD1); writeByte(0xD1);
writeInteger(int16_t(negated)); writeInteger(int16_t(negated));
} else if (value <= 0x80000000) { } else if (value <= 0x80000000) {
writeByte(0xD2); writeByte(0xD2);
writeInteger(int32_t(negated)); writeInteger(int32_t(negated));
} }
#if ARDUINOJSON_USE_LONG_LONG #if ARDUINOJSON_USE_LONG_LONG
else { else {
writeByte(0xD3); writeByte(0xD3);
writeInteger(int64_t(negated)); writeInteger(int64_t(negated));
} }
#endif #endif
} }
void visitPositiveInteger(UInt value) { void visitPositiveInteger(UInt value) {
if (value <= 0x7F) { if (value <= 0x7F) {
writeInteger(uint8_t(value)); writeInteger(uint8_t(value));
} else if (value <= 0xFF) { } else if (value <= 0xFF) {
writeByte(0xCC); writeByte(0xCC);
writeInteger(uint8_t(value)); writeInteger(uint8_t(value));
} else if (value <= 0xFFFF) { } else if (value <= 0xFFFF) {
writeByte(0xCD); writeByte(0xCD);
writeInteger(uint16_t(value)); writeInteger(uint16_t(value));
} else if (value <= 0xFFFFFFFF) { }
writeByte(0xCE); #if ARDUINOJSON_USE_LONG_LONG
writeInteger(uint32_t(value)); else if (value <= 0xFFFFFFFF)
} #else
#if ARDUINOJSON_USE_LONG_LONG else
else { #endif
writeByte(0xCF); {
writeInteger(uint64_t(value)); writeByte(0xCE);
} writeInteger(uint32_t(value));
#endif }
} #if ARDUINOJSON_USE_LONG_LONG
else {
void visitBoolean(bool value) { writeByte(0xCF);
writeByte(value ? 0xC3 : 0xC2); writeInteger(uint64_t(value));
} }
#endif
void visitNull() { }
writeByte(0xC0);
} void visitBoolean(bool value) {
writeByte(value ? 0xC3 : 0xC2);
size_t bytesWritten() const { }
return _bytesWritten;
} void visitNull() {
writeByte(0xC0);
private: }
void writeByte(uint8_t c) {
_bytesWritten += _writer.write(c); size_t bytesWritten() const {
} return _bytesWritten;
}
void writeBytes(const uint8_t* p, size_t n) {
_bytesWritten += _writer.write(p, n); private:
} void writeByte(uint8_t c) {
_bytesWritten += _writer.write(c);
template <typename T> }
void writeInteger(T value) {
fixEndianess(value); void writeBytes(const uint8_t* p, size_t n) {
writeBytes(reinterpret_cast<uint8_t*>(&value), sizeof(value)); _bytesWritten += _writer.write(p, n);
} }
TWriter _writer; template <typename T>
size_t _bytesWritten; void writeInteger(T value) {
}; fixEndianess(value);
writeBytes(reinterpret_cast<uint8_t*>(&value), sizeof(value));
template <typename TSource, typename TDestination> }
inline size_t serializeMsgPack(const TSource& source, TDestination& output) {
return serialize<MsgPackSerializer>(source, output); TWriter _writer;
} size_t _bytesWritten;
};
template <typename TSource>
inline size_t serializeMsgPack(const TSource& source, void* output, template <typename TSource, typename TDestination>
size_t size) { inline size_t serializeMsgPack(const TSource& source, TDestination& output) {
return serialize<MsgPackSerializer>(source, output, size); return serialize<MsgPackSerializer>(source, output);
} }
template <typename TSource> template <typename TSource>
inline size_t measureMsgPack(const TSource& source) { inline size_t serializeMsgPack(const TSource& source, void* output,
return measure<MsgPackSerializer>(source); size_t size) {
} return serialize<MsgPackSerializer>(source, output, size);
}
} // namespace ARDUINOJSON_NAMESPACE
template <typename TSource>
inline size_t measureMsgPack(const TSource& source) {
return measure<MsgPackSerializer>(source);
}
} // namespace ARDUINOJSON_NAMESPACE

82
lib_standalone/ArduinoJson/src/ArduinoJson/MsgPack/endianess.hpp → lib/ArduinoJson/src/ArduinoJson/MsgPack/endianess.hpp
View File

@@ -1,41 +1,41 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Polyfills/type_traits.hpp> #include <ArduinoJson/Polyfills/type_traits.hpp>
#include <ArduinoJson/Polyfills/utility.hpp> #include <ArduinoJson/Polyfills/utility.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
#if ARDUINOJSON_LITTLE_ENDIAN #if ARDUINOJSON_LITTLE_ENDIAN
inline void fixEndianess(uint8_t *p, integral_constant<size_t, 8>) { inline void fixEndianess(uint8_t *p, integral_constant<size_t, 8>) {
swap(p[0], p[7]); swap(p[0], p[7]);
swap(p[1], p[6]); swap(p[1], p[6]);
swap(p[2], p[5]); swap(p[2], p[5]);
swap(p[3], p[4]); swap(p[3], p[4]);
} }
inline void fixEndianess(uint8_t *p, integral_constant<size_t, 4>) { inline void fixEndianess(uint8_t *p, integral_constant<size_t, 4>) {
swap(p[0], p[3]); swap(p[0], p[3]);
swap(p[1], p[2]); swap(p[1], p[2]);
} }
inline void fixEndianess(uint8_t *p, integral_constant<size_t, 2>) { inline void fixEndianess(uint8_t *p, integral_constant<size_t, 2>) {
swap(p[0], p[1]); swap(p[0], p[1]);
} }
inline void fixEndianess(uint8_t *, integral_constant<size_t, 1>) {} inline void fixEndianess(uint8_t *, integral_constant<size_t, 1>) {}
template <typename T> template <typename T>
inline void fixEndianess(T &value) { inline void fixEndianess(T &value) {
fixEndianess(reinterpret_cast<uint8_t *>(&value), fixEndianess(reinterpret_cast<uint8_t *>(&value),
integral_constant<size_t, sizeof(T)>()); integral_constant<size_t, sizeof(T)>());
} }
#else #else
template <typename T> template <typename T>
inline void fixEndianess(T &) {} inline void fixEndianess(T &) {}
#endif #endif
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

36
lib_standalone/ArduinoJson/src/ArduinoJson/MsgPack/ieee754.hpp → lib/ArduinoJson/src/ArduinoJson/MsgPack/ieee754.hpp
View File

@@ -1,18 +1,18 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
inline void doubleToFloat(const uint8_t d[8], uint8_t f[4]) { inline void doubleToFloat(const uint8_t d[8], uint8_t f[4]) {
f[0] = uint8_t((d[0] & 0xC0) | (d[0] << 3 & 0x3f) | (d[1] >> 5)); f[0] = uint8_t((d[0] & 0xC0) | (d[0] << 3 & 0x3f) | (d[1] >> 5));
f[1] = uint8_t((d[1] << 3) | (d[2] >> 5)); f[1] = uint8_t((d[1] << 3) | (d[2] >> 5));
f[2] = uint8_t((d[2] << 3) | (d[3] >> 5)); f[2] = uint8_t((d[2] << 3) | (d[3] >> 5));
f[3] = uint8_t((d[3] << 3) | (d[4] >> 5)); f[3] = uint8_t((d[3] << 3) | (d[4] >> 5));
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

49
lib/ArduinoJson/src/ArduinoJson/Namespace.hpp Normal file
View File

@@ -0,0 +1,49 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020
// MIT License
#pragma once
#include <ArduinoJson/Configuration.hpp>
#include <ArduinoJson/version.hpp>
#ifndef ARDUINOJSON_NAMESPACE
#define ARDUINOJSON_HEX_DIGIT_0000() 0
#define ARDUINOJSON_HEX_DIGIT_0001() 1
#define ARDUINOJSON_HEX_DIGIT_0010() 2
#define ARDUINOJSON_HEX_DIGIT_0011() 3
#define ARDUINOJSON_HEX_DIGIT_0100() 4
#define ARDUINOJSON_HEX_DIGIT_0101() 5
#define ARDUINOJSON_HEX_DIGIT_0110() 6
#define ARDUINOJSON_HEX_DIGIT_0111() 7
#define ARDUINOJSON_HEX_DIGIT_1000() 8
#define ARDUINOJSON_HEX_DIGIT_1001() 9
#define ARDUINOJSON_HEX_DIGIT_1010() A
#define ARDUINOJSON_HEX_DIGIT_1011() B
#define ARDUINOJSON_HEX_DIGIT_1100() C
#define ARDUINOJSON_HEX_DIGIT_1101() D
#define ARDUINOJSON_HEX_DIGIT_1110() E
#define ARDUINOJSON_HEX_DIGIT_1111() F
#define ARDUINOJSON_HEX_DIGIT_(A, B, C, D) ARDUINOJSON_HEX_DIGIT_##A##B##C##D()
#define ARDUINOJSON_HEX_DIGIT(A, B, C, D) ARDUINOJSON_HEX_DIGIT_(A, B, C, D)
#define ARDUINOJSON_CONCAT_(A, B) A##B
#define ARDUINOJSON_CONCAT2(A, B) ARDUINOJSON_CONCAT_(A, B)
#define ARDUINOJSON_CONCAT4(A, B, C, D) \
ARDUINOJSON_CONCAT2(ARDUINOJSON_CONCAT2(A, B), ARDUINOJSON_CONCAT2(C, D))
#define ARDUINOJSON_NAMESPACE \
ARDUINOJSON_CONCAT4( \
ARDUINOJSON_CONCAT4(ArduinoJson, ARDUINOJSON_VERSION_MAJOR, \
ARDUINOJSON_VERSION_MINOR, \
ARDUINOJSON_VERSION_REVISION), \
_, \
ARDUINOJSON_HEX_DIGIT(0, ARDUINOJSON_USE_LONG_LONG, \
ARDUINOJSON_USE_DOUBLE, \
ARDUINOJSON_ENABLE_STRING_DEDUPLICATION), \
ARDUINOJSON_HEX_DIGIT( \
ARDUINOJSON_ENABLE_NAN, ARDUINOJSON_ENABLE_INFINITY, \
ARDUINOJSON_ENABLE_COMMENTS, ARDUINOJSON_DECODE_UNICODE))
#endif

34
lib_standalone/ArduinoJson/src/ArduinoJson/Numbers/Float.hpp → lib/ArduinoJson/src/ArduinoJson/Numbers/Float.hpp
View File

@@ -1,17 +1,17 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Configuration.hpp> #include <ArduinoJson/Configuration.hpp>
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
#if ARDUINOJSON_USE_DOUBLE #if ARDUINOJSON_USE_DOUBLE
typedef double Float; typedef double Float;
#else #else
typedef float Float; typedef float Float;
#endif #endif
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

174
lib_standalone/ArduinoJson/src/ArduinoJson/Numbers/FloatParts.hpp → lib/ArduinoJson/src/ArduinoJson/Numbers/FloatParts.hpp
View File

@@ -1,87 +1,87 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Configuration.hpp> #include <ArduinoJson/Configuration.hpp>
#include <ArduinoJson/Numbers/FloatTraits.hpp> #include <ArduinoJson/Numbers/FloatTraits.hpp>
#include <ArduinoJson/Polyfills/math.hpp> #include <ArduinoJson/Polyfills/math.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TFloat> template <typename TFloat>
struct FloatParts { struct FloatParts {
uint32_t integral; uint32_t integral;
uint32_t decimal; uint32_t decimal;
int16_t exponent; int16_t exponent;
int8_t decimalPlaces; int8_t decimalPlaces;
FloatParts(TFloat value) { FloatParts(TFloat value) {
uint32_t maxDecimalPart = sizeof(TFloat) >= 8 ? 1000000000 : 1000000; uint32_t maxDecimalPart = sizeof(TFloat) >= 8 ? 1000000000 : 1000000;
decimalPlaces = sizeof(TFloat) >= 8 ? 9 : 6; decimalPlaces = sizeof(TFloat) >= 8 ? 9 : 6;
exponent = normalize(value); exponent = normalize(value);
integral = uint32_t(value); integral = uint32_t(value);
// reduce number of decimal places by the number of integral places // reduce number of decimal places by the number of integral places
for (uint32_t tmp = integral; tmp >= 10; tmp /= 10) { for (uint32_t tmp = integral; tmp >= 10; tmp /= 10) {
maxDecimalPart /= 10; maxDecimalPart /= 10;
decimalPlaces--; decimalPlaces--;
} }
TFloat remainder = (value - TFloat(integral)) * TFloat(maxDecimalPart); TFloat remainder = (value - TFloat(integral)) * TFloat(maxDecimalPart);
decimal = uint32_t(remainder); decimal = uint32_t(remainder);
remainder = remainder - TFloat(decimal); remainder = remainder - TFloat(decimal);
// rounding: // rounding:
// increment by 1 if remainder >= 0.5 // increment by 1 if remainder >= 0.5
decimal += uint32_t(remainder * 2); decimal += uint32_t(remainder * 2);
if (decimal >= maxDecimalPart) { if (decimal >= maxDecimalPart) {
decimal = 0; decimal = 0;
integral++; integral++;
if (exponent && integral >= 10) { if (exponent && integral >= 10) {
exponent++; exponent++;
integral = 1; integral = 1;
} }
} }
// remove trailing zeros // remove trailing zeros
while (decimal % 10 == 0 && decimalPlaces > 0) { while (decimal % 10 == 0 && decimalPlaces > 0) {
decimal /= 10; decimal /= 10;
decimalPlaces--; decimalPlaces--;
} }
} }
static int16_t normalize(TFloat& value) { static int16_t normalize(TFloat& value) {
typedef FloatTraits<TFloat> traits; typedef FloatTraits<TFloat> traits;
int16_t powersOf10 = 0; int16_t powersOf10 = 0;
int8_t index = sizeof(TFloat) == 8 ? 8 : 5; int8_t index = sizeof(TFloat) == 8 ? 8 : 5;
int bit = 1 << index; int bit = 1 << index;
if (value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD) { if (value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD) {
for (; index >= 0; index--) { for (; index >= 0; index--) {
if (value >= traits::positiveBinaryPowerOfTen(index)) { if (value >= traits::positiveBinaryPowerOfTen(index)) {
value *= traits::negativeBinaryPowerOfTen(index); value *= traits::negativeBinaryPowerOfTen(index);
powersOf10 = int16_t(powersOf10 + bit); powersOf10 = int16_t(powersOf10 + bit);
} }
bit >>= 1; bit >>= 1;
} }
} }
if (value > 0 && value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD) { if (value > 0 && value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD) {
for (; index >= 0; index--) { for (; index >= 0; index--) {
if (value < traits::negativeBinaryPowerOfTenPlusOne(index)) { if (value < traits::negativeBinaryPowerOfTenPlusOne(index)) {
value *= traits::positiveBinaryPowerOfTen(index); value *= traits::positiveBinaryPowerOfTen(index);
powersOf10 = int16_t(powersOf10 - bit); powersOf10 = int16_t(powersOf10 - bit);
} }
bit >>= 1; bit >>= 1;
} }
} }
return powersOf10; return powersOf10;
} }
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

362
lib_standalone/ArduinoJson/src/ArduinoJson/Numbers/FloatTraits.hpp → lib/ArduinoJson/src/ArduinoJson/Numbers/FloatTraits.hpp
View File

@@ -1,181 +1,181 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <stddef.h> // for size_t #include <stddef.h> // for size_t
#include <stdint.h> #include <stdint.h>
#include <ArduinoJson/Configuration.hpp> #include <ArduinoJson/Configuration.hpp>
#include <ArduinoJson/Polyfills/alias_cast.hpp> #include <ArduinoJson/Polyfills/alias_cast.hpp>
#include <ArduinoJson/Polyfills/math.hpp> #include <ArduinoJson/Polyfills/math.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename T, size_t = sizeof(T)> template <typename T, size_t = sizeof(T)>
struct FloatTraits {}; struct FloatTraits {};
template <typename T> template <typename T>
struct FloatTraits<T, 8 /*64bits*/> { struct FloatTraits<T, 8 /*64bits*/> {
typedef uint64_t mantissa_type; typedef uint64_t mantissa_type;
static const short mantissa_bits = 52; static const short mantissa_bits = 52;
static const mantissa_type mantissa_max = static const mantissa_type mantissa_max =
(mantissa_type(1) << mantissa_bits) - 1; (mantissa_type(1) << mantissa_bits) - 1;
typedef int16_t exponent_type; typedef int16_t exponent_type;
static const exponent_type exponent_max = 308; static const exponent_type exponent_max = 308;
template <typename TExponent> template <typename TExponent>
static T make_float(T m, TExponent e) { static T make_float(T m, TExponent e) {
if (e > 0) { if (e > 0) {
for (uint8_t index = 0; e != 0; index++) { for (uint8_t index = 0; e != 0; index++) {
if (e & 1) if (e & 1)
m *= positiveBinaryPowerOfTen(index); m *= positiveBinaryPowerOfTen(index);
e >>= 1; e >>= 1;
} }
} else { } else {
e = TExponent(-e); e = TExponent(-e);
for (uint8_t index = 0; e != 0; index++) { for (uint8_t index = 0; e != 0; index++) {
if (e & 1) if (e & 1)
m *= negativeBinaryPowerOfTen(index); m *= negativeBinaryPowerOfTen(index);
e >>= 1; e >>= 1;
} }
} }
return m; return m;
} }
static T positiveBinaryPowerOfTen(int index) { static T positiveBinaryPowerOfTen(int index) {
static T factors[] = { static T factors[] = {
1e1, 1e1,
1e2, 1e2,
1e4, 1e4,
1e8, 1e8,
1e16, 1e16,
forge(0x4693B8B5, 0xB5056E17), // 1e32 forge(0x4693B8B5, 0xB5056E17), // 1e32
forge(0x4D384F03, 0xE93FF9F5), // 1e64 forge(0x4D384F03, 0xE93FF9F5), // 1e64
forge(0x5A827748, 0xF9301D32), // 1e128 forge(0x5A827748, 0xF9301D32), // 1e128
forge(0x75154FDD, 0x7F73BF3C) // 1e256 forge(0x75154FDD, 0x7F73BF3C) // 1e256
}; };
return factors[index]; return factors[index];
} }
static T negativeBinaryPowerOfTen(int index) { static T negativeBinaryPowerOfTen(int index) {
static T factors[] = { static T factors[] = {
forge(0x3FB99999, 0x9999999A), // 1e-1 forge(0x3FB99999, 0x9999999A), // 1e-1
forge(0x3F847AE1, 0x47AE147B), // 1e-2 forge(0x3F847AE1, 0x47AE147B), // 1e-2
forge(0x3F1A36E2, 0xEB1C432D), // 1e-4 forge(0x3F1A36E2, 0xEB1C432D), // 1e-4
forge(0x3E45798E, 0xE2308C3A), // 1e-8 forge(0x3E45798E, 0xE2308C3A), // 1e-8
forge(0x3C9CD2B2, 0x97D889BC), // 1e-16 forge(0x3C9CD2B2, 0x97D889BC), // 1e-16
forge(0x3949F623, 0xD5A8A733), // 1e-32 forge(0x3949F623, 0xD5A8A733), // 1e-32
forge(0x32A50FFD, 0x44F4A73D), // 1e-64 forge(0x32A50FFD, 0x44F4A73D), // 1e-64
forge(0x255BBA08, 0xCF8C979D), // 1e-128 forge(0x255BBA08, 0xCF8C979D), // 1e-128
forge(0x0AC80628, 0x64AC6F43) // 1e-256 forge(0x0AC80628, 0x64AC6F43) // 1e-256
}; };
return factors[index]; return factors[index];
} }
static T negativeBinaryPowerOfTenPlusOne(int index) { static T negativeBinaryPowerOfTenPlusOne(int index) {
static T factors[] = { static T factors[] = {
1e0, 1e0,
forge(0x3FB99999, 0x9999999A), // 1e-1 forge(0x3FB99999, 0x9999999A), // 1e-1
forge(0x3F50624D, 0xD2F1A9FC), // 1e-3 forge(0x3F50624D, 0xD2F1A9FC), // 1e-3
forge(0x3E7AD7F2, 0x9ABCAF48), // 1e-7 forge(0x3E7AD7F2, 0x9ABCAF48), // 1e-7
forge(0x3CD203AF, 0x9EE75616), // 1e-15 forge(0x3CD203AF, 0x9EE75616), // 1e-15
forge(0x398039D6, 0x65896880), // 1e-31 forge(0x398039D6, 0x65896880), // 1e-31
forge(0x32DA53FC, 0x9631D10D), // 1e-63 forge(0x32DA53FC, 0x9631D10D), // 1e-63
forge(0x25915445, 0x81B7DEC2), // 1e-127 forge(0x25915445, 0x81B7DEC2), // 1e-127
forge(0x0AFE07B2, 0x7DD78B14) // 1e-255 forge(0x0AFE07B2, 0x7DD78B14) // 1e-255
}; };
return factors[index]; return factors[index];
} }
static T nan() { static T nan() {
return forge(0x7ff80000, 0x00000000); return forge(0x7ff80000, 0x00000000);
} }
static T inf() { static T inf() {
return forge(0x7ff00000, 0x00000000); return forge(0x7ff00000, 0x00000000);
} }
static T highest() { static T highest() {
return forge(0x7FEFFFFF, 0xFFFFFFFF); return forge(0x7FEFFFFF, 0xFFFFFFFF);
} }
static T lowest() { static T lowest() {
return forge(0xFFEFFFFF, 0xFFFFFFFF); return forge(0xFFEFFFFF, 0xFFFFFFFF);
} }
// constructs a double floating point values from its binary representation // constructs a double floating point values from its binary representation
// we use this function to workaround platforms with single precision literals // we use this function to workaround platforms with single precision literals
// (for example, when -fsingle-precision-constant is passed to GCC) // (for example, when -fsingle-precision-constant is passed to GCC)
static T forge(uint32_t msb, uint32_t lsb) { static T forge(uint32_t msb, uint32_t lsb) {
return alias_cast<T>((uint64_t(msb) << 32) | lsb); return alias_cast<T>((uint64_t(msb) << 32) | lsb);
} }
}; };
template <typename T> template <typename T>
struct FloatTraits<T, 4 /*32bits*/> { struct FloatTraits<T, 4 /*32bits*/> {
typedef uint32_t mantissa_type; typedef uint32_t mantissa_type;
static const short mantissa_bits = 23; static const short mantissa_bits = 23;
static const mantissa_type mantissa_max = static const mantissa_type mantissa_max =
(mantissa_type(1) << mantissa_bits) - 1; (mantissa_type(1) << mantissa_bits) - 1;
typedef int8_t exponent_type; typedef int8_t exponent_type;
static const exponent_type exponent_max = 38; static const exponent_type exponent_max = 38;
template <typename TExponent> template <typename TExponent>
static T make_float(T m, TExponent e) { static T make_float(T m, TExponent e) {
if (e > 0) { if (e > 0) {
for (uint8_t index = 0; e != 0; index++) { for (uint8_t index = 0; e != 0; index++) {
if (e & 1) if (e & 1)
m *= positiveBinaryPowerOfTen(index); m *= positiveBinaryPowerOfTen(index);
e >>= 1; e >>= 1;
} }
} else { } else {
e = -e; e = -e;
for (uint8_t index = 0; e != 0; index++) { for (uint8_t index = 0; e != 0; index++) {
if (e & 1) if (e & 1)
m *= negativeBinaryPowerOfTen(index); m *= negativeBinaryPowerOfTen(index);
e >>= 1; e >>= 1;
} }
} }
return m; return m;
} }
static T positiveBinaryPowerOfTen(int index) { static T positiveBinaryPowerOfTen(int index) {
static T factors[] = {1e1f, 1e2f, 1e4f, 1e8f, 1e16f, 1e32f}; static T factors[] = {1e1f, 1e2f, 1e4f, 1e8f, 1e16f, 1e32f};
return factors[index]; return factors[index];
} }
static T negativeBinaryPowerOfTen(int index) { static T negativeBinaryPowerOfTen(int index) {
static T factors[] = {1e-1f, 1e-2f, 1e-4f, 1e-8f, 1e-16f, 1e-32f}; static T factors[] = {1e-1f, 1e-2f, 1e-4f, 1e-8f, 1e-16f, 1e-32f};
return factors[index]; return factors[index];
} }
static T negativeBinaryPowerOfTenPlusOne(int index) { static T negativeBinaryPowerOfTenPlusOne(int index) {
static T factors[] = {1e0f, 1e-1f, 1e-3f, 1e-7f, 1e-15f, 1e-31f}; static T factors[] = {1e0f, 1e-1f, 1e-3f, 1e-7f, 1e-15f, 1e-31f};
return factors[index]; return factors[index];
} }
static T forge(uint32_t bits) { static T forge(uint32_t bits) {
return alias_cast<T>(bits); return alias_cast<T>(bits);
} }
static T nan() { static T nan() {
return forge(0x7fc00000); return forge(0x7fc00000);
} }
static T inf() { static T inf() {
return forge(0x7f800000); return forge(0x7f800000);
} }
static T highest() { static T highest() {
return forge(0x7f7fffff); return forge(0x7f7fffff);
} }
static T lowest() { static T lowest() {
return forge(0xFf7fffff); return forge(0xFf7fffff);
} }
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

32
lib/ArduinoJson/src/ArduinoJson/Numbers/Integer.hpp Normal file
View File

@@ -0,0 +1,32 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020
// MIT License
#pragma once
#include <ArduinoJson/Configuration.hpp>
#include <ArduinoJson/Namespace.hpp>
#include <stdint.h> // int64_t
namespace ARDUINOJSON_NAMESPACE {
#if ARDUINOJSON_USE_LONG_LONG
typedef int64_t Integer;
typedef uint64_t UInt;
#else
typedef long Integer;
typedef unsigned long UInt;
#endif
} // namespace ARDUINOJSON_NAMESPACE
#if ARDUINOJSON_HAS_LONG_LONG && !ARDUINOJSON_USE_LONG_LONG
#define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T) \
static_assert(sizeof(T) <= sizeof(ARDUINOJSON_NAMESPACE::Integer), \
"To use 64-bit integers with ArduinoJson, you must set " \
"ARDUINOJSON_USE_LONG_LONG to 1. See " \
"https://arduinojson.org/v6/api/config/use_long_long/");
#else
#define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T)
#endif

121
lib/ArduinoJson/src/ArduinoJson/Numbers/arithmeticCompare.hpp Normal file
View File

@@ -0,0 +1,121 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020
// MIT License
#pragma once
#include <ArduinoJson/Numbers/Integer.hpp>
#include <ArduinoJson/Polyfills/type_traits.hpp>
namespace ARDUINOJSON_NAMESPACE {
enum CompareResult {
COMPARE_RESULT_DIFFER = 0,
COMPARE_RESULT_EQUAL = 1,
COMPARE_RESULT_GREATER = 2,
COMPARE_RESULT_LESS = 4,
COMPARE_RESULT_GREATER_OR_EQUAL = 3,
COMPARE_RESULT_LESS_OR_EQUAL = 5
};
template <typename T>
CompareResult arithmeticCompare(const T &lhs, const T &rhs) {
if (lhs < rhs)
return COMPARE_RESULT_LESS;
else if (lhs > rhs)
return COMPARE_RESULT_GREATER;
else
return COMPARE_RESULT_EQUAL;
}
template <typename T1, typename T2>
CompareResult arithmeticCompare(
const T1 &lhs, const T2 &rhs,
typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
sizeof(T1) < sizeof(T2),
int // Using int instead of void to avoid C2572 on
// Visual Studio 2012, 2013, and 2015
>::type * = 0) {
return arithmeticCompare<T2>(static_cast<T2>(lhs), rhs);
}
template <typename T1, typename T2>
CompareResult arithmeticCompare(
const T1 &lhs, const T2 &rhs,
typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
sizeof(T2) < sizeof(T1)>::type * = 0) {
return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
}
template <typename T1, typename T2>
CompareResult arithmeticCompare(
const T1 &lhs, const T2 &rhs,
typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
is_signed<T1>::value == is_signed<T2>::value &&
sizeof(T2) == sizeof(T1)>::type * = 0) {
return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
}
template <typename T1, typename T2>
CompareResult arithmeticCompare(
const T1 &lhs, const T2 &rhs,
typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
is_unsigned<T1>::value && is_signed<T2>::value &&
sizeof(T2) == sizeof(T1)>::type * = 0) {
if (rhs < 0)
return COMPARE_RESULT_GREATER;
return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
}
template <typename T1, typename T2>
CompareResult arithmeticCompare(
const T1 &lhs, const T2 &rhs,
typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
is_signed<T1>::value && is_unsigned<T2>::value &&
sizeof(T2) == sizeof(T1)>::type * = 0) {
if (lhs < 0)
return COMPARE_RESULT_LESS;
return arithmeticCompare<T2>(static_cast<T2>(lhs), rhs);
}
template <typename T1, typename T2>
CompareResult arithmeticCompare(
const T1 &lhs, const T2 &rhs,
typename enable_if<is_floating_point<T1>::value ||
is_floating_point<T2>::value>::type * = 0) {
return arithmeticCompare<double>(static_cast<double>(lhs),
static_cast<double>(rhs));
}
template <typename T2>
CompareResult arithmeticCompareNegateLeft(
UInt, const T2 &, typename enable_if<is_unsigned<T2>::value>::type * = 0) {
return COMPARE_RESULT_LESS;
}
template <typename T2>
CompareResult arithmeticCompareNegateLeft(
UInt lhs, const T2 &rhs,
typename enable_if<is_signed<T2>::value>::type * = 0) {
if (rhs > 0)
return COMPARE_RESULT_LESS;
return arithmeticCompare(-rhs, static_cast<T2>(lhs));
}
template <typename T1>
CompareResult arithmeticCompareNegateRight(
const T1 &, UInt, typename enable_if<is_unsigned<T1>::value>::type * = 0) {
return COMPARE_RESULT_GREATER;
}
template <typename T1>
CompareResult arithmeticCompareNegateRight(
const T1 &lhs, UInt rhs,
typename enable_if<is_signed<T1>::value>::type * = 0) {
if (lhs > 0)
return COMPARE_RESULT_GREATER;
return arithmeticCompare(static_cast<T1>(rhs), -lhs);
}
} // namespace ARDUINOJSON_NAMESPACE

210
lib_standalone/ArduinoJson/src/ArduinoJson/Numbers/convertNumber.hpp → lib/ArduinoJson/src/ArduinoJson/Numbers/convertNumber.hpp
View File

@@ -1,105 +1,105 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#if defined(__clang__) #if defined(__clang__)
#pragma clang diagnostic push #pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wconversion" #pragma clang diagnostic ignored "-Wconversion"
#elif defined(__GNUC__) #elif defined(__GNUC__)
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#endif #endif
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
#include <ArduinoJson/Numbers/Float.hpp> #include <ArduinoJson/Numbers/Float.hpp>
#include <ArduinoJson/Numbers/FloatTraits.hpp> #include <ArduinoJson/Numbers/FloatTraits.hpp>
#include <ArduinoJson/Numbers/Integer.hpp> #include <ArduinoJson/Numbers/Integer.hpp>
#include <ArduinoJson/Polyfills/limits.hpp> #include <ArduinoJson/Polyfills/limits.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TOut, typename TIn> template <typename TOut, typename TIn>
typename enable_if<is_integral<TOut>::value && sizeof(TOut) <= sizeof(TIn), typename enable_if<is_integral<TOut>::value && sizeof(TOut) <= sizeof(TIn),
bool>::type bool>::type
canStorePositiveInteger(TIn value) { canStorePositiveInteger(TIn value) {
return value <= TIn(numeric_limits<TOut>::highest()); return value <= TIn(numeric_limits<TOut>::highest());
} }
template <typename TOut, typename TIn> template <typename TOut, typename TIn>
typename enable_if<is_integral<TOut>::value && sizeof(TIn) < sizeof(TOut), typename enable_if<is_integral<TOut>::value && sizeof(TIn) < sizeof(TOut),
bool>::type bool>::type
canStorePositiveInteger(TIn) { canStorePositiveInteger(TIn) {
return true; return true;
} }
template <typename TOut, typename TIn> template <typename TOut, typename TIn>
typename enable_if<is_floating_point<TOut>::value, bool>::type typename enable_if<is_floating_point<TOut>::value, bool>::type
canStorePositiveInteger(TIn) { canStorePositiveInteger(TIn) {
return true; return true;
} }
template <typename TOut, typename TIn> template <typename TOut, typename TIn>
typename enable_if<is_floating_point<TOut>::value, bool>::type typename enable_if<is_floating_point<TOut>::value, bool>::type
canStoreNegativeInteger(TIn) { canStoreNegativeInteger(TIn) {
return true; return true;
} }
template <typename TOut, typename TIn> template <typename TOut, typename TIn>
typename enable_if<is_integral<TOut>::value && is_signed<TOut>::value && typename enable_if<is_integral<TOut>::value && is_signed<TOut>::value &&
sizeof(TOut) <= sizeof(TIn), sizeof(TOut) <= sizeof(TIn),
bool>::type bool>::type
canStoreNegativeInteger(TIn value) { canStoreNegativeInteger(TIn value) {
return value <= TIn(numeric_limits<TOut>::highest()) + 1; return value <= TIn(numeric_limits<TOut>::highest()) + 1;
} }
template <typename TOut, typename TIn> template <typename TOut, typename TIn>
typename enable_if<is_integral<TOut>::value && is_signed<TOut>::value && typename enable_if<is_integral<TOut>::value && is_signed<TOut>::value &&
sizeof(TIn) < sizeof(TOut), sizeof(TIn) < sizeof(TOut),
bool>::type bool>::type
canStoreNegativeInteger(TIn) { canStoreNegativeInteger(TIn) {
return true; return true;
} }
template <typename TOut, typename TIn> template <typename TOut, typename TIn>
typename enable_if<is_integral<TOut>::value && is_unsigned<TOut>::value, typename enable_if<is_integral<TOut>::value && is_unsigned<TOut>::value,
bool>::type bool>::type
canStoreNegativeInteger(TIn) { canStoreNegativeInteger(TIn) {
return false; return false;
} }
template <typename TOut, typename TIn> template <typename TOut, typename TIn>
TOut convertPositiveInteger(TIn value) { TOut convertPositiveInteger(TIn value) {
return canStorePositiveInteger<TOut>(value) ? TOut(value) : 0; return canStorePositiveInteger<TOut>(value) ? TOut(value) : 0;
} }
template <typename TOut, typename TIn> template <typename TOut, typename TIn>
TOut convertNegativeInteger(TIn value) { TOut convertNegativeInteger(TIn value) {
return canStoreNegativeInteger<TOut>(value) ? TOut(~value + 1) : 0; return canStoreNegativeInteger<TOut>(value) ? TOut(~value + 1) : 0;
} }
template <typename TOut, typename TIn> template <typename TOut, typename TIn>
typename enable_if<is_floating_point<TOut>::value, TOut>::type convertFloat( typename enable_if<is_floating_point<TOut>::value, TOut>::type convertFloat(
TIn value) { TIn value) {
return TOut(value); return TOut(value);
} }
template <typename TOut, typename TIn> template <typename TOut, typename TIn>
typename enable_if<!is_floating_point<TOut>::value, TOut>::type convertFloat( typename enable_if<!is_floating_point<TOut>::value, TOut>::type convertFloat(
TIn value) { TIn value) {
return value >= numeric_limits<TOut>::lowest() && return value >= numeric_limits<TOut>::lowest() &&
value <= numeric_limits<TOut>::highest() value <= numeric_limits<TOut>::highest()
? TOut(value) ? TOut(value)
: 0; : 0;
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE
#if defined(__clang__) #if defined(__clang__)
#pragma clang diagnostic pop #pragma clang diagnostic pop
#elif defined(__GNUC__) #elif defined(__GNUC__)
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
#endif #endif
#endif #endif

38
lib_standalone/ArduinoJson/src/ArduinoJson/Numbers/parseFloat.hpp → lib/ArduinoJson/src/ArduinoJson/Numbers/parseFloat.hpp
View File

@@ -1,18 +1,20 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Numbers/convertNumber.hpp> #include <ArduinoJson/Numbers/convertNumber.hpp>
#include <ArduinoJson/Numbers/parseNumber.hpp> #include <ArduinoJson/Numbers/parseNumber.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename T> template <typename T>
inline T parseFloat(const char* s) { inline T parseFloat(const char* s) {
// try to reuse the same parameters as JsonDeserializer // try to reuse the same parameters as JsonDeserializer
typedef typename choose_largest<Float, T>::type TFloat; typedef typename choose_largest<Float, T>::type TFloat;
return parseNumber<TFloat, UInt>(s).template as<T>(); ParsedNumber<TFloat, UInt> value;
} parseNumber(s, value);
} // namespace ARDUINOJSON_NAMESPACE return value.template as<T>();
}
} // namespace ARDUINOJSON_NAMESPACE

40
lib_standalone/ArduinoJson/src/ArduinoJson/Numbers/parseInteger.hpp → lib/ArduinoJson/src/ArduinoJson/Numbers/parseInteger.hpp
View File

@@ -1,19 +1,21 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Numbers/convertNumber.hpp> #include <ArduinoJson/Numbers/convertNumber.hpp>
#include <ArduinoJson/Numbers/parseNumber.hpp> #include <ArduinoJson/Numbers/parseNumber.hpp>
#include <ArduinoJson/Polyfills/type_traits.hpp> #include <ArduinoJson/Polyfills/type_traits.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename T> template <typename T>
T parseInteger(const char *s) { T parseInteger(const char *s) {
// try to reuse the same parameters as JsonDeserializer // try to reuse the same parameters as JsonDeserializer
typedef typename choose_largest<UInt, typename make_unsigned<T>::type>::type typedef typename choose_largest<UInt, typename make_unsigned<T>::type>::type
TUInt; TUInt;
return parseNumber<Float, TUInt>(s).template as<T>(); ParsedNumber<Float, TUInt> value;
} parseNumber(s, value);
} // namespace ARDUINOJSON_NAMESPACE return value.template as<T>();
}
} // namespace ARDUINOJSON_NAMESPACE

340
lib_standalone/ArduinoJson/src/ArduinoJson/Numbers/parseNumber.hpp → lib/ArduinoJson/src/ArduinoJson/Numbers/parseNumber.hpp
View File

@@ -1,163 +1,177 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Numbers/FloatTraits.hpp> #include <ArduinoJson/Numbers/FloatTraits.hpp>
#include <ArduinoJson/Numbers/convertNumber.hpp> #include <ArduinoJson/Numbers/convertNumber.hpp>
#include <ArduinoJson/Polyfills/assert.hpp> #include <ArduinoJson/Polyfills/assert.hpp>
#include <ArduinoJson/Polyfills/ctype.hpp> #include <ArduinoJson/Polyfills/ctype.hpp>
#include <ArduinoJson/Polyfills/math.hpp> #include <ArduinoJson/Polyfills/math.hpp>
#include <ArduinoJson/Polyfills/type_traits.hpp> #include <ArduinoJson/Polyfills/type_traits.hpp>
#include <ArduinoJson/Variant/VariantContent.hpp> #include <ArduinoJson/Variant/VariantContent.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TFloat, typename TUInt> template <typename TFloat, typename TUInt>
struct ParsedNumber { struct ParsedNumber {
ParsedNumber() : uintValue(0), floatValue(0), _type(VALUE_IS_NULL) {} ParsedNumber() : _type(VALUE_IS_NULL) {}
ParsedNumber(TUInt value, bool is_negative) void setInteger(TUInt value, bool is_negative) {
: uintValue(value), uintValue = value;
floatValue(TFloat(value)), _type = uint8_t(is_negative ? VALUE_IS_NEGATIVE_INTEGER
_type(uint8_t(is_negative ? VALUE_IS_NEGATIVE_INTEGER : VALUE_IS_POSITIVE_INTEGER);
: VALUE_IS_POSITIVE_INTEGER)) {} }
ParsedNumber(TFloat value) : floatValue(value), _type(VALUE_IS_FLOAT) {}
void setFloat(TFloat value) {
template <typename T> floatValue = value;
T as() const { _type = VALUE_IS_FLOAT;
switch (_type) { }
case VALUE_IS_NEGATIVE_INTEGER:
return convertNegativeInteger<T>(uintValue); template <typename T>
case VALUE_IS_POSITIVE_INTEGER: T as() const {
return convertPositiveInteger<T>(uintValue); switch (_type) {
case VALUE_IS_FLOAT: case VALUE_IS_NEGATIVE_INTEGER:
return convertFloat<T>(floatValue); return convertNegativeInteger<T>(uintValue);
default: case VALUE_IS_POSITIVE_INTEGER:
return 0; return convertPositiveInteger<T>(uintValue);
} case VALUE_IS_FLOAT:
} return convertFloat<T>(floatValue);
default:
uint8_t type() const { return 0;
return _type; }
} }
TUInt uintValue; uint8_t type() const {
TFloat floatValue; return _type;
uint8_t _type; }
};
union {
template <typename A, typename B> TUInt uintValue;
struct choose_largest : conditional<(sizeof(A) > sizeof(B)), A, B> {}; TFloat floatValue;
};
template <typename TFloat, typename TUInt> uint8_t _type;
inline ParsedNumber<TFloat, TUInt> parseNumber(const char *s) { }; // namespace ARDUINOJSON_NAMESPACE
typedef FloatTraits<TFloat> traits;
typedef typename choose_largest<typename traits::mantissa_type, TUInt>::type template <typename A, typename B>
mantissa_t; struct choose_largest : conditional<(sizeof(A) > sizeof(B)), A, B> {};
typedef typename traits::exponent_type exponent_t;
typedef ParsedNumber<TFloat, TUInt> return_type; template <typename TFloat, typename TUInt>
inline void parseNumber(const char* s, ParsedNumber<TFloat, TUInt>& result) {
ARDUINOJSON_ASSERT(s != 0); typedef FloatTraits<TFloat> traits;
typedef typename choose_largest<typename traits::mantissa_type, TUInt>::type
bool is_negative = false; mantissa_t;
switch (*s) { typedef typename traits::exponent_type exponent_t;
case '-':
is_negative = true; ARDUINOJSON_ASSERT(s != 0);
s++;
break; bool is_negative = false;
case '+': switch (*s) {
s++; case '-':
break; is_negative = true;
} s++;
break;
#if ARDUINOJSON_ENABLE_NAN case '+':
if (*s == 'n' || *s == 'N') s++;
return traits::nan(); break;
#endif }
#if ARDUINOJSON_ENABLE_INFINITY #if ARDUINOJSON_ENABLE_NAN
if (*s == 'i' || *s == 'I') if (*s == 'n' || *s == 'N') {
return is_negative ? -traits::inf() : traits::inf(); result.setFloat(traits::nan());
#endif return;
}
if (!isdigit(*s) && *s != '.')
return return_type(); #endif
mantissa_t mantissa = 0; #if ARDUINOJSON_ENABLE_INFINITY
exponent_t exponent_offset = 0; if (*s == 'i' || *s == 'I') {
const mantissa_t maxUint = TUInt(-1); result.setFloat(is_negative ? -traits::inf() : traits::inf());
return;
while (isdigit(*s)) { }
uint8_t digit = uint8_t(*s - '0'); #endif
if (mantissa > maxUint / 10)
break; if (!isdigit(*s) && *s != '.')
mantissa *= 10; return;
if (mantissa > maxUint - digit)
break; mantissa_t mantissa = 0;
mantissa += digit; exponent_t exponent_offset = 0;
s++; const mantissa_t maxUint = TUInt(-1);
}
while (isdigit(*s)) {
if (*s == '\0') uint8_t digit = uint8_t(*s - '0');
return return_type(TUInt(mantissa), is_negative); if (mantissa > maxUint / 10)
break;
// avoid mantissa overflow mantissa *= 10;
while (mantissa > traits::mantissa_max) { if (mantissa > maxUint - digit)
mantissa /= 10; break;
exponent_offset++; mantissa += digit;
} s++;
}
// remaing digits can't fit in the mantissa
while (isdigit(*s)) { if (*s == '\0') {
exponent_offset++; result.setInteger(TUInt(mantissa), is_negative);
s++; return;
} }
if (*s == '.') { // avoid mantissa overflow
s++; while (mantissa > traits::mantissa_max) {
while (isdigit(*s)) { mantissa /= 10;
if (mantissa < traits::mantissa_max / 10) { exponent_offset++;
mantissa = mantissa * 10 + uint8_t(*s - '0'); }
exponent_offset--;
} // remaing digits can't fit in the mantissa
s++; while (isdigit(*s)) {
} exponent_offset++;
} s++;
}
int exponent = 0;
if (*s == 'e' || *s == 'E') { if (*s == '.') {
s++; s++;
bool negative_exponent = false; while (isdigit(*s)) {
if (*s == '-') { if (mantissa < traits::mantissa_max / 10) {
negative_exponent = true; mantissa = mantissa * 10 + uint8_t(*s - '0');
s++; exponent_offset--;
} else if (*s == '+') { }
s++; s++;
} }
}
while (isdigit(*s)) {
exponent = exponent * 10 + (*s - '0'); int exponent = 0;
if (exponent + exponent_offset > traits::exponent_max) { if (*s == 'e' || *s == 'E') {
if (negative_exponent) s++;
return is_negative ? -0.0f : 0.0f; bool negative_exponent = false;
else if (*s == '-') {
return is_negative ? -traits::inf() : traits::inf(); negative_exponent = true;
} s++;
s++; } else if (*s == '+') {
} s++;
if (negative_exponent) }
exponent = -exponent;
} while (isdigit(*s)) {
exponent += exponent_offset; exponent = exponent * 10 + (*s - '0');
if (exponent + exponent_offset > traits::exponent_max) {
// we should be at the end of the string, otherwise it's an error if (negative_exponent)
if (*s != '\0') result.setFloat(is_negative ? -0.0f : 0.0f);
return return_type(); else
result.setFloat(is_negative ? -traits::inf() : traits::inf());
TFloat result = traits::make_float(static_cast<TFloat>(mantissa), exponent); return;
}
return is_negative ? -result : result; s++;
} }
} // namespace ARDUINOJSON_NAMESPACE if (negative_exponent)
exponent = -exponent;
}
exponent += exponent_offset;
// we should be at the end of the string, otherwise it's an error
if (*s != '\0')
return;
TFloat final_result =
traits::make_float(static_cast<TFloat>(mantissa), exponent);
result.setFloat(is_negative ? -final_result : final_result);
}
} // namespace ARDUINOJSON_NAMESPACE

373
lib_standalone/ArduinoJson/src/ArduinoJson/Object/MemberProxy.hpp → lib/ArduinoJson/src/ArduinoJson/Object/MemberProxy.hpp
View File

@@ -1,186 +1,187 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Configuration.hpp> #include <ArduinoJson/Configuration.hpp>
#include <ArduinoJson/Operators/VariantOperators.hpp> #include <ArduinoJson/Polyfills/type_traits.hpp>
#include <ArduinoJson/Polyfills/type_traits.hpp> #include <ArduinoJson/Variant/VariantOperators.hpp>
#include <ArduinoJson/Variant/VariantRef.hpp>
#ifdef _MSC_VER #include <ArduinoJson/Variant/VariantShortcuts.hpp>
#pragma warning(push) #include <ArduinoJson/Variant/VariantTo.hpp>
#pragma warning(disable : 4522)
#endif #ifdef _MSC_VER
#pragma warning(push)
namespace ARDUINOJSON_NAMESPACE { #pragma warning(disable : 4522)
#endif
template <typename TObject, typename TStringRef>
class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >, namespace ARDUINOJSON_NAMESPACE {
public Visitable {
typedef MemberProxy<TObject, TStringRef> this_type; template <typename TObject, typename TStringRef>
class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
public: public VariantShortcuts<MemberProxy<TObject, TStringRef> >,
FORCE_INLINE MemberProxy(TObject variant, TStringRef key) public Visitable {
: _object(variant), _key(key) {} typedef MemberProxy<TObject, TStringRef> this_type;
FORCE_INLINE MemberProxy(const MemberProxy &src) public:
: _object(src._object), _key(src._key) {} FORCE_INLINE MemberProxy(TObject variant, TStringRef key)
: _object(variant), _key(key) {}
FORCE_INLINE operator VariantConstRef() const {
return getUpstreamMember(); FORCE_INLINE MemberProxy(const MemberProxy &src)
} : _object(src._object), _key(src._key) {}
FORCE_INLINE this_type &operator=(const this_type &src) { FORCE_INLINE operator VariantConstRef() const {
getOrAddUpstreamMember().set(src); return getUpstreamMember();
return *this; }
}
FORCE_INLINE this_type &operator=(const this_type &src) {
template <typename TValue> getOrAddUpstreamMember().set(src);
FORCE_INLINE typename enable_if<!is_array<TValue>::value, this_type &>::type return *this;
operator=(const TValue &src) { }
getOrAddUpstreamMember().set(src);
return *this; template <typename TValue>
} FORCE_INLINE typename enable_if<!is_array<TValue>::value, this_type &>::type
operator=(const TValue &src) {
// operator=(char*) getOrAddUpstreamMember().set(src);
// operator=(const char*) return *this;
// operator=(const __FlashStringHelper*) }
template <typename TChar>
FORCE_INLINE this_type &operator=(TChar *src) { // operator=(char*)
getOrAddUpstreamMember().set(src); // operator=(const char*)
return *this; // operator=(const __FlashStringHelper*)
} template <typename TChar>
FORCE_INLINE this_type &operator=(TChar *src) {
FORCE_INLINE bool operator==(VariantConstRef rhs) const { getOrAddUpstreamMember().set(src);
return static_cast<VariantConstRef>(getUpstreamMember()) == rhs; return *this;
} }
FORCE_INLINE bool operator!=(VariantConstRef rhs) const { FORCE_INLINE void clear() const {
return static_cast<VariantConstRef>(getUpstreamMember()) != rhs; getUpstreamMember().clear();
} }
FORCE_INLINE void clear() const { FORCE_INLINE bool isNull() const {
getUpstreamMember().clear(); return getUpstreamMember().isNull();
} }
FORCE_INLINE bool isNull() const { template <typename TValue>
return getUpstreamMember().isNull(); FORCE_INLINE typename VariantAs<TValue>::type as() const {
} return getUpstreamMember().template as<TValue>();
}
template <typename TValue>
FORCE_INLINE typename VariantAs<TValue>::type as() const { template <typename T>
return getUpstreamMember().template as<TValue>(); FORCE_INLINE operator T() const {
} return getUpstreamMember();
}
template <typename TValue>
FORCE_INLINE bool is() const { template <typename TValue>
return getUpstreamMember().template is<TValue>(); FORCE_INLINE bool is() const {
} return getUpstreamMember().template is<TValue>();
}
FORCE_INLINE size_t size() const {
return getUpstreamMember().size(); FORCE_INLINE size_t size() const {
} return getUpstreamMember().size();
}
FORCE_INLINE void remove(size_t index) const {
getUpstreamMember().remove(index); FORCE_INLINE void remove(size_t index) const {
} getUpstreamMember().remove(index);
// remove(char*) const }
// remove(const char*) const // remove(char*) const
// remove(const __FlashStringHelper*) const // remove(const char*) const
template <typename TChar> // remove(const __FlashStringHelper*) const
FORCE_INLINE typename enable_if<IsString<TChar *>::value>::type remove( template <typename TChar>
TChar *key) const { FORCE_INLINE typename enable_if<IsString<TChar *>::value>::type remove(
getUpstreamMember().remove(key); TChar *key) const {
} getUpstreamMember().remove(key);
// remove(const std::string&) const }
// remove(const String&) const // remove(const std::string&) const
template <typename TString> // remove(const String&) const
FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove( template <typename TString>
const TString &key) const { FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
getUpstreamMember().remove(key); const TString &key) const {
} getUpstreamMember().remove(key);
}
template <typename TValue>
FORCE_INLINE typename VariantTo<TValue>::type to() { template <typename TValue>
return getOrAddUpstreamMember().template to<TValue>(); FORCE_INLINE typename VariantTo<TValue>::type to() {
} return getOrAddUpstreamMember().template to<TValue>();
}
template <typename TValue>
FORCE_INLINE bool set(const TValue &value) { template <typename TValue>
return getOrAddUpstreamMember().set(value); FORCE_INLINE bool set(const TValue &value) {
} return getOrAddUpstreamMember().set(value);
}
// set(char*) const
// set(const char*) const // set(char*) const
// set(const __FlashStringHelper*) const // set(const char*) const
template <typename TChar> // set(const __FlashStringHelper*) const
FORCE_INLINE bool set(TChar *value) { template <typename TChar>
return getOrAddUpstreamMember().set(value); FORCE_INLINE bool set(TChar *value) {
} return getOrAddUpstreamMember().set(value);
}
template <typename Visitor>
void accept(Visitor &visitor) const { template <typename Visitor>
return getUpstreamMember().accept(visitor); void accept(Visitor &visitor) const {
} return getUpstreamMember().accept(visitor);
}
FORCE_INLINE VariantRef addElement() const {
return getOrAddUpstreamMember().addElement(); FORCE_INLINE VariantRef addElement() const {
} return getOrAddUpstreamMember().addElement();
}
FORCE_INLINE VariantRef getElement(size_t index) const {
return getUpstreamMember().getElement(index); FORCE_INLINE VariantRef getElement(size_t index) const {
} return getUpstreamMember().getElement(index);
}
FORCE_INLINE VariantRef getOrAddElement(size_t index) const {
return getOrAddUpstreamMember().getOrAddElement(index); FORCE_INLINE VariantRef getOrAddElement(size_t index) const {
} return getOrAddUpstreamMember().getOrAddElement(index);
}
// getMember(char*) const
// getMember(const char*) const // getMember(char*) const
// getMember(const __FlashStringHelper*) const // getMember(const char*) const
template <typename TChar> // getMember(const __FlashStringHelper*) const
FORCE_INLINE VariantRef getMember(TChar *key) const { template <typename TChar>
return getUpstreamMember().getMember(key); FORCE_INLINE VariantRef getMember(TChar *key) const {
} return getUpstreamMember().getMember(key);
}
// getMember(const std::string&) const
// getMember(const String&) const // getMember(const std::string&) const
template <typename TString> // getMember(const String&) const
FORCE_INLINE VariantRef getMember(const TString &key) const { template <typename TString>
return getUpstreamMember().getMember(key); FORCE_INLINE VariantRef getMember(const TString &key) const {
} return getUpstreamMember().getMember(key);
}
// getOrAddMember(char*) const
// getOrAddMember(const char*) const // getOrAddMember(char*) const
// getOrAddMember(const __FlashStringHelper*) const // getOrAddMember(const char*) const
template <typename TChar> // getOrAddMember(const __FlashStringHelper*) const
FORCE_INLINE VariantRef getOrAddMember(TChar *key) const { template <typename TChar>
return getOrAddUpstreamMember().getOrAddMember(key); FORCE_INLINE VariantRef getOrAddMember(TChar *key) const {
} return getOrAddUpstreamMember().getOrAddMember(key);
}
// getOrAddMember(const std::string&) const
// getOrAddMember(const String&) const // getOrAddMember(const std::string&) const
template <typename TString> // getOrAddMember(const String&) const
FORCE_INLINE VariantRef getOrAddMember(const TString &key) const { template <typename TString>
return getOrAddUpstreamMember().getOrAddMember(key); FORCE_INLINE VariantRef getOrAddMember(const TString &key) const {
} return getOrAddUpstreamMember().getOrAddMember(key);
}
private:
FORCE_INLINE VariantRef getUpstreamMember() const { private:
return _object.getMember(_key); FORCE_INLINE VariantRef getUpstreamMember() const {
} return _object.getMember(_key);
}
FORCE_INLINE VariantRef getOrAddUpstreamMember() const {
return _object.getOrAddMember(_key); FORCE_INLINE VariantRef getOrAddUpstreamMember() const {
} return _object.getOrAddMember(_key);
}
TObject _object;
TStringRef _key; TObject _object;
}; TStringRef _key;
};
} // namespace ARDUINOJSON_NAMESPACE
} // namespace ARDUINOJSON_NAMESPACE
#ifdef _MSC_VER
#pragma warning(pop) #ifdef _MSC_VER
#endif #pragma warning(pop)
#endif

100
lib_standalone/ArduinoJson/src/ArduinoJson/Object/ObjectFunctions.hpp → lib/ArduinoJson/src/ArduinoJson/Object/ObjectFunctions.hpp
View File

@@ -1,50 +1,50 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Collection/CollectionData.hpp> #include <ArduinoJson/Collection/CollectionData.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename Visitor> template <typename Visitor>
void objectAccept(const CollectionData *obj, Visitor &visitor) { void objectAccept(const CollectionData *obj, Visitor &visitor) {
if (obj) if (obj)
visitor.visitObject(*obj); visitor.visitObject(*obj);
else else
visitor.visitNull(); visitor.visitNull();
} }
inline bool objectEquals(const CollectionData *lhs, const CollectionData *rhs) { inline bool objectEquals(const CollectionData *lhs, const CollectionData *rhs) {
if (lhs == rhs) if (lhs == rhs)
return true; return true;
if (!lhs || !rhs) if (!lhs || !rhs)
return false; return false;
return lhs->equalsObject(*rhs); return lhs->equalsObject(*rhs);
} }
template <typename TAdaptedString> template <typename TAdaptedString>
inline VariantData *objectGetMember(const CollectionData *obj, inline VariantData *objectGetMember(const CollectionData *obj,
TAdaptedString key) { TAdaptedString key) {
if (!obj) if (!obj)
return 0; return 0;
return obj->getMember(key); return obj->getMember(key);
} }
template <typename TAdaptedString> template <typename TAdaptedString>
void objectRemove(CollectionData *obj, TAdaptedString key) { void objectRemove(CollectionData *obj, TAdaptedString key) {
if (!obj) if (!obj)
return; return;
obj->removeMember(key); obj->removeMember(key);
} }
template <typename TAdaptedString> template <typename TAdaptedString>
inline VariantData *objectGetOrAddMember(CollectionData *obj, inline VariantData *objectGetOrAddMember(CollectionData *obj,
TAdaptedString key, MemoryPool *pool) { TAdaptedString key, MemoryPool *pool) {
if (!obj) if (!obj)
return 0; return 0;
return obj->getOrAddMember(key, pool); return obj->getOrAddMember(key, pool);
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

138
lib_standalone/ArduinoJson/src/ArduinoJson/Object/ObjectImpl.hpp → lib/ArduinoJson/src/ArduinoJson/Object/ObjectImpl.hpp
View File

@@ -1,69 +1,69 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Array/ArrayRef.hpp> #include <ArduinoJson/Array/ArrayRef.hpp>
#include <ArduinoJson/Object/ObjectRef.hpp> #include <ArduinoJson/Object/ObjectRef.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TObject> template <typename TObject>
template <typename TString> template <typename TString>
inline ArrayRef ObjectShortcuts<TObject>::createNestedArray( inline ArrayRef ObjectShortcuts<TObject>::createNestedArray(
const TString& key) const { const TString& key) const {
return impl()->getOrAddMember(key).template to<ArrayRef>(); return impl()->getOrAddMember(key).template to<ArrayRef>();
} }
template <typename TObject> template <typename TObject>
template <typename TChar> template <typename TChar>
inline ArrayRef ObjectShortcuts<TObject>::createNestedArray(TChar* key) const { inline ArrayRef ObjectShortcuts<TObject>::createNestedArray(TChar* key) const {
return impl()->getOrAddMember(key).template to<ArrayRef>(); return impl()->getOrAddMember(key).template to<ArrayRef>();
} }
template <typename TObject> template <typename TObject>
template <typename TString> template <typename TString>
inline ObjectRef ObjectShortcuts<TObject>::createNestedObject( inline ObjectRef ObjectShortcuts<TObject>::createNestedObject(
const TString& key) const { const TString& key) const {
return impl()->getOrAddMember(key).template to<ObjectRef>(); return impl()->getOrAddMember(key).template to<ObjectRef>();
} }
template <typename TObject> template <typename TObject>
template <typename TChar> template <typename TChar>
inline ObjectRef ObjectShortcuts<TObject>::createNestedObject( inline ObjectRef ObjectShortcuts<TObject>::createNestedObject(
TChar* key) const { TChar* key) const {
return impl()->getOrAddMember(key).template to<ObjectRef>(); return impl()->getOrAddMember(key).template to<ObjectRef>();
} }
template <typename TObject> template <typename TObject>
template <typename TString> template <typename TString>
inline typename enable_if<IsString<TString>::value, bool>::type inline typename enable_if<IsString<TString>::value, bool>::type
ObjectShortcuts<TObject>::containsKey(const TString& key) const { ObjectShortcuts<TObject>::containsKey(const TString& key) const {
return !impl()->getMember(key).isUndefined(); return !impl()->getMember(key).isUndefined();
} }
template <typename TObject> template <typename TObject>
template <typename TChar> template <typename TChar>
inline typename enable_if<IsString<TChar*>::value, bool>::type inline typename enable_if<IsString<TChar*>::value, bool>::type
ObjectShortcuts<TObject>::containsKey(TChar* key) const { ObjectShortcuts<TObject>::containsKey(TChar* key) const {
return !impl()->getMember(key).isUndefined(); return !impl()->getMember(key).isUndefined();
} }
template <typename TObject> template <typename TObject>
template <typename TString> template <typename TString>
inline typename enable_if<IsString<TString*>::value, inline typename enable_if<IsString<TString*>::value,
MemberProxy<TObject, TString*> >::type MemberProxy<TObject, TString*> >::type
ObjectShortcuts<TObject>::operator[](TString* key) const { ObjectShortcuts<TObject>::operator[](TString* key) const {
return MemberProxy<TObject, TString*>(*impl(), key); return MemberProxy<TObject, TString*>(*impl(), key);
} }
template <typename TObject> template <typename TObject>
template <typename TString> template <typename TString>
inline typename enable_if<IsString<TString>::value, inline typename enable_if<IsString<TString>::value,
MemberProxy<TObject, TString> >::type MemberProxy<TObject, TString> >::type
ObjectShortcuts<TObject>::operator[](const TString& key) const { ObjectShortcuts<TObject>::operator[](const TString& key) const {
return MemberProxy<TObject, TString>(*impl(), key); return MemberProxy<TObject, TString>(*impl(), key);
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

246
lib_standalone/ArduinoJson/src/ArduinoJson/Object/ObjectIterator.hpp → lib/ArduinoJson/src/ArduinoJson/Object/ObjectIterator.hpp
View File

@@ -1,123 +1,123 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Object/Pair.hpp> #include <ArduinoJson/Object/Pair.hpp>
#include <ArduinoJson/Variant/SlotFunctions.hpp> #include <ArduinoJson/Variant/SlotFunctions.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
class PairPtr { class PairPtr {
public: public:
PairPtr(MemoryPool *pool, VariantSlot *slot) : _pair(pool, slot) {} PairPtr(MemoryPool *pool, VariantSlot *slot) : _pair(pool, slot) {}
const Pair *operator->() const { const Pair *operator->() const {
return &_pair; return &_pair;
} }
const Pair &operator*() const { const Pair &operator*() const {
return _pair; return _pair;
} }
private: private:
Pair _pair; Pair _pair;
}; };
class ObjectIterator { class ObjectIterator {
public: public:
ObjectIterator() : _slot(0) {} ObjectIterator() : _slot(0) {}
explicit ObjectIterator(MemoryPool *pool, VariantSlot *slot) explicit ObjectIterator(MemoryPool *pool, VariantSlot *slot)
: _pool(pool), _slot(slot) {} : _pool(pool), _slot(slot) {}
Pair operator*() const { Pair operator*() const {
return Pair(_pool, _slot); return Pair(_pool, _slot);
} }
PairPtr operator->() { PairPtr operator->() {
return PairPtr(_pool, _slot); return PairPtr(_pool, _slot);
} }
bool operator==(const ObjectIterator &other) const { bool operator==(const ObjectIterator &other) const {
return _slot == other._slot; return _slot == other._slot;
} }
bool operator!=(const ObjectIterator &other) const { bool operator!=(const ObjectIterator &other) const {
return _slot != other._slot; return _slot != other._slot;
} }
ObjectIterator &operator++() { ObjectIterator &operator++() {
_slot = _slot->next(); _slot = _slot->next();
return *this; return *this;
} }
ObjectIterator &operator+=(size_t distance) { ObjectIterator &operator+=(size_t distance) {
_slot = _slot->next(distance); _slot = _slot->next(distance);
return *this; return *this;
} }
VariantSlot *internal() { VariantSlot *internal() {
return _slot; return _slot;
} }
private: private:
MemoryPool *_pool; MemoryPool *_pool;
VariantSlot *_slot; VariantSlot *_slot;
}; };
class PairConstPtr { class PairConstPtr {
public: public:
PairConstPtr(const VariantSlot *slot) : _pair(slot) {} PairConstPtr(const VariantSlot *slot) : _pair(slot) {}
const PairConst *operator->() const { const PairConst *operator->() const {
return &_pair; return &_pair;
} }
const PairConst &operator*() const { const PairConst &operator*() const {
return _pair; return _pair;
} }
private: private:
PairConst _pair; PairConst _pair;
}; };
class ObjectConstIterator { class ObjectConstIterator {
public: public:
ObjectConstIterator() : _slot(0) {} ObjectConstIterator() : _slot(0) {}
explicit ObjectConstIterator(const VariantSlot *slot) : _slot(slot) {} explicit ObjectConstIterator(const VariantSlot *slot) : _slot(slot) {}
PairConst operator*() const { PairConst operator*() const {
return PairConst(_slot); return PairConst(_slot);
} }
PairConstPtr operator->() { PairConstPtr operator->() {
return PairConstPtr(_slot); return PairConstPtr(_slot);
} }
bool operator==(const ObjectConstIterator &other) const { bool operator==(const ObjectConstIterator &other) const {
return _slot == other._slot; return _slot == other._slot;
} }
bool operator!=(const ObjectConstIterator &other) const { bool operator!=(const ObjectConstIterator &other) const {
return _slot != other._slot; return _slot != other._slot;
} }
ObjectConstIterator &operator++() { ObjectConstIterator &operator++() {
_slot = _slot->next(); _slot = _slot->next();
return *this; return *this;
} }
ObjectConstIterator &operator+=(size_t distance) { ObjectConstIterator &operator+=(size_t distance) {
_slot = _slot->next(distance); _slot = _slot->next(distance);
return *this; return *this;
} }
const VariantSlot *internal() { const VariantSlot *internal() {
return _slot; return _slot;
} }
private: private:
const VariantSlot *_slot; const VariantSlot *_slot;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

478
lib_standalone/ArduinoJson/src/ArduinoJson/Object/ObjectRef.hpp → lib/ArduinoJson/src/ArduinoJson/Object/ObjectRef.hpp
View File

@@ -1,239 +1,239 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Object/ObjectFunctions.hpp> #include <ArduinoJson/Object/ObjectFunctions.hpp>
#include <ArduinoJson/Object/ObjectIterator.hpp> #include <ArduinoJson/Object/ObjectIterator.hpp>
// Returns the size (in bytes) of an object with n elements. // Returns the size (in bytes) of an object with n elements.
// Can be very handy to determine the size of a StaticMemoryPool. // Can be very handy to determine the size of a StaticMemoryPool.
#define JSON_OBJECT_SIZE(NUMBER_OF_ELEMENTS) \ #define JSON_OBJECT_SIZE(NUMBER_OF_ELEMENTS) \
((NUMBER_OF_ELEMENTS) * sizeof(ARDUINOJSON_NAMESPACE::VariantSlot)) ((NUMBER_OF_ELEMENTS) * sizeof(ARDUINOJSON_NAMESPACE::VariantSlot))
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TData> template <typename TData>
class ObjectRefBase { class ObjectRefBase {
public: public:
operator VariantConstRef() const { operator VariantConstRef() const {
const void* data = _data; // prevent warning cast-align const void* data = _data; // prevent warning cast-align
return VariantConstRef(reinterpret_cast<const VariantData*>(data)); return VariantConstRef(reinterpret_cast<const VariantData*>(data));
} }
template <typename Visitor> template <typename Visitor>
FORCE_INLINE void accept(Visitor& visitor) const { FORCE_INLINE void accept(Visitor& visitor) const {
objectAccept(_data, visitor); objectAccept(_data, visitor);
} }
FORCE_INLINE bool isNull() const { FORCE_INLINE bool isNull() const {
return _data == 0; return _data == 0;
} }
FORCE_INLINE operator bool() const { FORCE_INLINE operator bool() const {
return _data != 0; return _data != 0;
} }
FORCE_INLINE size_t memoryUsage() const { FORCE_INLINE size_t memoryUsage() const {
return _data ? _data->memoryUsage() : 0; return _data ? _data->memoryUsage() : 0;
} }
FORCE_INLINE size_t nesting() const { FORCE_INLINE size_t nesting() const {
return _data ? _data->nesting() : 0; return _data ? _data->nesting() : 0;
} }
FORCE_INLINE size_t size() const { FORCE_INLINE size_t size() const {
return _data ? _data->size() : 0; return _data ? _data->size() : 0;
} }
protected: protected:
ObjectRefBase(TData* data) : _data(data) {} ObjectRefBase(TData* data) : _data(data) {}
TData* _data; TData* _data;
}; };
class ObjectConstRef : public ObjectRefBase<const CollectionData>, class ObjectConstRef : public ObjectRefBase<const CollectionData>,
public Visitable { public Visitable {
friend class ObjectRef; friend class ObjectRef;
typedef ObjectRefBase<const CollectionData> base_type; typedef ObjectRefBase<const CollectionData> base_type;
public: public:
typedef ObjectConstIterator iterator; typedef ObjectConstIterator iterator;
ObjectConstRef() : base_type(0) {} ObjectConstRef() : base_type(0) {}
ObjectConstRef(const CollectionData* data) : base_type(data) {} ObjectConstRef(const CollectionData* data) : base_type(data) {}
FORCE_INLINE iterator begin() const { FORCE_INLINE iterator begin() const {
if (!_data) if (!_data)
return iterator(); return iterator();
return iterator(_data->head()); return iterator(_data->head());
} }
FORCE_INLINE iterator end() const { FORCE_INLINE iterator end() const {
return iterator(); return iterator();
} }
// containsKey(const std::string&) const // containsKey(const std::string&) const
// containsKey(const String&) const // containsKey(const String&) const
template <typename TString> template <typename TString>
FORCE_INLINE bool containsKey(const TString& key) const { FORCE_INLINE bool containsKey(const TString& key) const {
return !getMember(key).isUndefined(); return !getMember(key).isUndefined();
} }
// containsKey(char*) const // containsKey(char*) const
// containsKey(const char*) const // containsKey(const char*) const
// containsKey(const __FlashStringHelper*) const // containsKey(const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
FORCE_INLINE bool containsKey(TChar* key) const { FORCE_INLINE bool containsKey(TChar* key) const {
return !getMember(key).isUndefined(); return !getMember(key).isUndefined();
} }
// getMember(const std::string&) const // getMember(const std::string&) const
// getMember(const String&) const // getMember(const String&) const
template <typename TString> template <typename TString>
FORCE_INLINE VariantConstRef getMember(const TString& key) const { FORCE_INLINE VariantConstRef getMember(const TString& key) const {
return get_impl(adaptString(key)); return get_impl(adaptString(key));
} }
// getMember(char*) const // getMember(char*) const
// getMember(const char*) const // getMember(const char*) const
// getMember(const __FlashStringHelper*) const // getMember(const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
FORCE_INLINE VariantConstRef getMember(TChar* key) const { FORCE_INLINE VariantConstRef getMember(TChar* key) const {
return get_impl(adaptString(key)); return get_impl(adaptString(key));
} }
// operator[](const std::string&) const // operator[](const std::string&) const
// operator[](const String&) const // operator[](const String&) const
template <typename TString> template <typename TString>
FORCE_INLINE FORCE_INLINE
typename enable_if<IsString<TString>::value, VariantConstRef>::type typename enable_if<IsString<TString>::value, VariantConstRef>::type
operator[](const TString& key) const { operator[](const TString& key) const {
return get_impl(adaptString(key)); return get_impl(adaptString(key));
} }
// operator[](char*) const // operator[](char*) const
// operator[](const char*) const // operator[](const char*) const
// operator[](const __FlashStringHelper*) const // operator[](const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
FORCE_INLINE FORCE_INLINE
typename enable_if<IsString<TChar*>::value, VariantConstRef>::type typename enable_if<IsString<TChar*>::value, VariantConstRef>::type
operator[](TChar* key) const { operator[](TChar* key) const {
return get_impl(adaptString(key)); return get_impl(adaptString(key));
} }
FORCE_INLINE bool operator==(ObjectConstRef rhs) const { FORCE_INLINE bool operator==(ObjectConstRef rhs) const {
return objectEquals(_data, rhs._data); return objectEquals(_data, rhs._data);
} }
private: private:
template <typename TAdaptedString> template <typename TAdaptedString>
FORCE_INLINE VariantConstRef get_impl(TAdaptedString key) const { FORCE_INLINE VariantConstRef get_impl(TAdaptedString key) const {
return VariantConstRef(objectGetMember(_data, key)); return VariantConstRef(objectGetMember(_data, key));
} }
}; };
class ObjectRef : public ObjectRefBase<CollectionData>, class ObjectRef : public ObjectRefBase<CollectionData>,
public ObjectShortcuts<ObjectRef>, public ObjectShortcuts<ObjectRef>,
public Visitable { public Visitable {
typedef ObjectRefBase<CollectionData> base_type; typedef ObjectRefBase<CollectionData> base_type;
public: public:
typedef ObjectIterator iterator; typedef ObjectIterator iterator;
FORCE_INLINE ObjectRef() : base_type(0), _pool(0) {} FORCE_INLINE ObjectRef() : base_type(0), _pool(0) {}
FORCE_INLINE ObjectRef(MemoryPool* buf, CollectionData* data) FORCE_INLINE ObjectRef(MemoryPool* buf, CollectionData* data)
: base_type(data), _pool(buf) {} : base_type(data), _pool(buf) {}
operator VariantRef() const { operator VariantRef() const {
void* data = _data; // prevent warning cast-align void* data = _data; // prevent warning cast-align
return VariantRef(_pool, reinterpret_cast<VariantData*>(data)); return VariantRef(_pool, reinterpret_cast<VariantData*>(data));
} }
operator ObjectConstRef() const { operator ObjectConstRef() const {
return ObjectConstRef(_data); return ObjectConstRef(_data);
} }
FORCE_INLINE iterator begin() const { FORCE_INLINE iterator begin() const {
if (!_data) if (!_data)
return iterator(); return iterator();
return iterator(_pool, _data->head()); return iterator(_pool, _data->head());
} }
FORCE_INLINE iterator end() const { FORCE_INLINE iterator end() const {
return iterator(); return iterator();
} }
void clear() const { void clear() const {
if (!_data) if (!_data)
return; return;
_data->clear(); _data->clear();
} }
FORCE_INLINE bool set(ObjectConstRef src) { FORCE_INLINE bool set(ObjectConstRef src) {
if (!_data || !src._data) if (!_data || !src._data)
return false; return false;
return _data->copyFrom(*src._data, _pool); return _data->copyFrom(*src._data, _pool);
} }
// getMember(const std::string&) const // getMember(const std::string&) const
// getMember(const String&) const // getMember(const String&) const
template <typename TString> template <typename TString>
FORCE_INLINE VariantRef getMember(const TString& key) const { FORCE_INLINE VariantRef getMember(const TString& key) const {
return VariantRef(_pool, objectGetMember(_data, adaptString(key))); return VariantRef(_pool, objectGetMember(_data, adaptString(key)));
} }
// getMember(char*) const // getMember(char*) const
// getMember(const char*) const // getMember(const char*) const
// getMember(const __FlashStringHelper*) const // getMember(const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
FORCE_INLINE VariantRef getMember(TChar* key) const { FORCE_INLINE VariantRef getMember(TChar* key) const {
return VariantRef(_pool, objectGetMember(_data, adaptString(key))); return VariantRef(_pool, objectGetMember(_data, adaptString(key)));
} }
// getOrAddMember(const std::string&) const // getOrAddMember(const std::string&) const
// getOrAddMember(const String&) const // getOrAddMember(const String&) const
template <typename TString> template <typename TString>
FORCE_INLINE VariantRef getOrAddMember(const TString& key) const { FORCE_INLINE VariantRef getOrAddMember(const TString& key) const {
return VariantRef(_pool, return VariantRef(_pool,
objectGetOrAddMember(_data, adaptString(key), _pool)); objectGetOrAddMember(_data, adaptString(key), _pool));
} }
// getOrAddMember(char*) const // getOrAddMember(char*) const
// getOrAddMember(const char*) const // getOrAddMember(const char*) const
// getOrAddMember(const __FlashStringHelper*) const // getOrAddMember(const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
FORCE_INLINE VariantRef getOrAddMember(TChar* key) const { FORCE_INLINE VariantRef getOrAddMember(TChar* key) const {
return VariantRef(_pool, return VariantRef(_pool,
objectGetOrAddMember(_data, adaptString(key), _pool)); objectGetOrAddMember(_data, adaptString(key), _pool));
} }
FORCE_INLINE bool operator==(ObjectRef rhs) const { FORCE_INLINE bool operator==(ObjectRef rhs) const {
return objectEquals(_data, rhs._data); return objectEquals(_data, rhs._data);
} }
FORCE_INLINE void remove(iterator it) const { FORCE_INLINE void remove(iterator it) const {
if (!_data) if (!_data)
return; return;
_data->removeSlot(it.internal()); _data->removeSlot(it.internal());
} }
// remove(const std::string&) const // remove(const std::string&) const
// remove(const String&) const // remove(const String&) const
template <typename TString> template <typename TString>
FORCE_INLINE void remove(const TString& key) const { FORCE_INLINE void remove(const TString& key) const {
objectRemove(_data, adaptString(key)); objectRemove(_data, adaptString(key));
} }
// remove(char*) const // remove(char*) const
// remove(const char*) const // remove(const char*) const
// remove(const __FlashStringHelper*) const // remove(const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
FORCE_INLINE void remove(TChar* key) const { FORCE_INLINE void remove(TChar* key) const {
objectRemove(_data, adaptString(key)); objectRemove(_data, adaptString(key));
} }
private: private:
MemoryPool* _pool; MemoryPool* _pool;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

146
lib_standalone/ArduinoJson/src/ArduinoJson/Object/ObjectShortcuts.hpp → lib/ArduinoJson/src/ArduinoJson/Object/ObjectShortcuts.hpp
View File

@@ -1,73 +1,73 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Polyfills/attributes.hpp> #include <ArduinoJson/Polyfills/attributes.hpp>
#include <ArduinoJson/Polyfills/type_traits.hpp> #include <ArduinoJson/Polyfills/type_traits.hpp>
#include <ArduinoJson/Strings/StringAdapters.hpp> #include <ArduinoJson/Strings/StringAdapters.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename TParent, typename TStringRef> template <typename TParent, typename TStringRef>
class MemberProxy; class MemberProxy;
template <typename TObject> template <typename TObject>
class ObjectShortcuts { class ObjectShortcuts {
public: public:
// containsKey(const std::string&) const // containsKey(const std::string&) const
// containsKey(const String&) const // containsKey(const String&) const
template <typename TString> template <typename TString>
FORCE_INLINE typename enable_if<IsString<TString>::value, bool>::type FORCE_INLINE typename enable_if<IsString<TString>::value, bool>::type
containsKey(const TString &key) const; containsKey(const TString &key) const;
// containsKey(char*) const // containsKey(char*) const
// containsKey(const char*) const // containsKey(const char*) const
// containsKey(const __FlashStringHelper*) const // containsKey(const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
FORCE_INLINE typename enable_if<IsString<TChar *>::value, bool>::type FORCE_INLINE typename enable_if<IsString<TChar *>::value, bool>::type
containsKey(TChar *key) const; containsKey(TChar *key) const;
// operator[](const std::string&) const // operator[](const std::string&) const
// operator[](const String&) const // operator[](const String&) const
template <typename TString> template <typename TString>
FORCE_INLINE typename enable_if<IsString<TString>::value, FORCE_INLINE typename enable_if<IsString<TString>::value,
MemberProxy<TObject, TString> >::type MemberProxy<TObject, TString> >::type
operator[](const TString &key) const; operator[](const TString &key) const;
// operator[](char*) const // operator[](char*) const
// operator[](const char*) const // operator[](const char*) const
// operator[](const __FlashStringHelper*) const // operator[](const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
FORCE_INLINE typename enable_if<IsString<TChar *>::value, FORCE_INLINE typename enable_if<IsString<TChar *>::value,
MemberProxy<TObject, TChar *> >::type MemberProxy<TObject, TChar *> >::type
operator[](TChar *key) const; operator[](TChar *key) const;
// createNestedArray(const std::string&) const // createNestedArray(const std::string&) const
// createNestedArray(const String&) const // createNestedArray(const String&) const
template <typename TString> template <typename TString>
FORCE_INLINE ArrayRef createNestedArray(const TString &key) const; FORCE_INLINE ArrayRef createNestedArray(const TString &key) const;
// createNestedArray(char*) const // createNestedArray(char*) const
// createNestedArray(const char*) const // createNestedArray(const char*) const
// createNestedArray(const __FlashStringHelper*) const // createNestedArray(const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
FORCE_INLINE ArrayRef createNestedArray(TChar *key) const; FORCE_INLINE ArrayRef createNestedArray(TChar *key) const;
// createNestedObject(const std::string&) const // createNestedObject(const std::string&) const
// createNestedObject(const String&) const // createNestedObject(const String&) const
template <typename TString> template <typename TString>
ObjectRef createNestedObject(const TString &key) const; ObjectRef createNestedObject(const TString &key) const;
// createNestedObject(char*) const // createNestedObject(char*) const
// createNestedObject(const char*) const // createNestedObject(const char*) const
// createNestedObject(const __FlashStringHelper*) const // createNestedObject(const __FlashStringHelper*) const
template <typename TChar> template <typename TChar>
ObjectRef createNestedObject(TChar *key) const; ObjectRef createNestedObject(TChar *key) const;
private: private:
const TObject *impl() const { const TObject *impl() const {
return static_cast<const TObject *>(this); return static_cast<const TObject *>(this);
} }
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

110
lib_standalone/ArduinoJson/src/ArduinoJson/Object/Pair.hpp → lib/ArduinoJson/src/ArduinoJson/Object/Pair.hpp
View File

@@ -1,55 +1,55 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Strings/String.hpp> #include <ArduinoJson/Strings/String.hpp>
#include <ArduinoJson/Variant/VariantRef.hpp> #include <ArduinoJson/Variant/VariantRef.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
// A key value pair for CollectionData. // A key value pair for CollectionData.
class Pair { class Pair {
public: public:
Pair(MemoryPool* pool, VariantSlot* slot) { Pair(MemoryPool* pool, VariantSlot* slot) {
if (slot) { if (slot) {
_key = String(slot->key(), !slot->ownsKey()); _key = String(slot->key(), !slot->ownsKey());
_value = VariantRef(pool, slot->data()); _value = VariantRef(pool, slot->data());
} }
} }
String key() const { String key() const {
return _key; return _key;
} }
VariantRef value() const { VariantRef value() const {
return _value; return _value;
} }
private: private:
String _key; String _key;
VariantRef _value; VariantRef _value;
}; };
class PairConst { class PairConst {
public: public:
PairConst(const VariantSlot* slot) { PairConst(const VariantSlot* slot) {
if (slot) { if (slot) {
_key = String(slot->key(), !slot->ownsKey()); _key = String(slot->key(), !slot->ownsKey());
_value = VariantConstRef(slot->data()); _value = VariantConstRef(slot->data());
} }
} }
String key() const { String key() const {
return _key; return _key;
} }
VariantConstRef value() const { VariantConstRef value() const {
return _value; return _value;
} }
private: private:
String _key; String _key;
VariantConstRef _value; VariantConstRef _value;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

58
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/alias_cast.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/alias_cast.hpp
View File

@@ -1,29 +1,29 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> // for size_t #include <stdlib.h> // for size_t
#include <ArduinoJson/Configuration.hpp> #include <ArduinoJson/Configuration.hpp>
#include "math.hpp" #include "math.hpp"
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename T, typename F> template <typename T, typename F>
struct alias_cast_t { struct alias_cast_t {
union { union {
F raw; F raw;
T data; T data;
}; };
}; };
template <typename T, typename F> template <typename T, typename F>
T alias_cast(F raw_data) { T alias_cast(F raw_data) {
alias_cast_t<T, F> ac; alias_cast_t<T, F> ac;
ac.raw = raw_data; ac.raw = raw_data;
return ac.data; return ac.data;
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

28
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/assert.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/assert.hpp
View File

@@ -1,14 +1,14 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Configuration.hpp> #include <ArduinoJson/Configuration.hpp>
#if ARDUINOJSON_DEBUG #if ARDUINOJSON_DEBUG
#include <assert.h> #include <assert.h>
#define ARDUINOJSON_ASSERT(X) assert(X) #define ARDUINOJSON_ASSERT(X) assert(X)
#else #else
#define ARDUINOJSON_ASSERT(X) ((void)0) #define ARDUINOJSON_ASSERT(X) ((void)0)
#endif #endif

90
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/attributes.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/attributes.hpp
View File

@@ -1,45 +1,45 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#ifdef _MSC_VER // Visual Studio #ifdef _MSC_VER // Visual Studio
#define FORCE_INLINE // __forceinline causes C4714 when returning std::string #define FORCE_INLINE // __forceinline causes C4714 when returning std::string
#define NO_INLINE __declspec(noinline) #define NO_INLINE __declspec(noinline)
#define DEPRECATED(msg) __declspec(deprecated(msg)) #define DEPRECATED(msg) __declspec(deprecated(msg))
#elif defined(__GNUC__) // GCC or Clang #elif defined(__GNUC__) // GCC or Clang
#define FORCE_INLINE __attribute__((always_inline)) #define FORCE_INLINE __attribute__((always_inline))
#define NO_INLINE __attribute__((noinline)) #define NO_INLINE __attribute__((noinline))
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5) #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
#define DEPRECATED(msg) __attribute__((deprecated(msg))) #define DEPRECATED(msg) __attribute__((deprecated(msg)))
#else #else
#define DEPRECATED(msg) __attribute__((deprecated)) #define DEPRECATED(msg) __attribute__((deprecated))
#endif #endif
#else // Other compilers #else // Other compilers
#define FORCE_INLINE #define FORCE_INLINE
#define NO_INLINE #define NO_INLINE
#define DEPRECATED(msg) #define DEPRECATED(msg)
#endif #endif
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
#define NOEXCEPT noexcept #define NOEXCEPT noexcept
#else #else
#define NOEXCEPT throw() #define NOEXCEPT throw()
#endif #endif
#if defined(__has_attribute) #if defined(__has_attribute)
#if __has_attribute(no_sanitize) #if __has_attribute(no_sanitize)
#define ARDUINOJSON_NO_SANITIZE(check) __attribute__((no_sanitize(check))) #define ARDUINOJSON_NO_SANITIZE(check) __attribute__((no_sanitize(check)))
#else #else
#define ARDUINOJSON_NO_SANITIZE(check) #define ARDUINOJSON_NO_SANITIZE(check)
#endif #endif
#else #else
#define ARDUINOJSON_NO_SANITIZE(check) #define ARDUINOJSON_NO_SANITIZE(check)
#endif #endif

36
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/ctype.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/ctype.hpp
View File

@@ -1,18 +1,18 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
inline bool isdigit(char c) { inline bool isdigit(char c) {
return '0' <= c && c <= '9'; return '0' <= c && c <= '9';
} }
inline bool issign(char c) { inline bool issign(char c) {
return '-' == c || c == '+'; return '-' == c || c == '+';
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

68
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/gsl/not_null.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/gsl/not_null.hpp
View File

@@ -1,34 +1,34 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
#include <ArduinoJson/Polyfills/assert.hpp> #include <ArduinoJson/Polyfills/assert.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename T> template <typename T>
class not_null { class not_null {
public: public:
explicit not_null(T ptr) : _ptr(ptr) { explicit not_null(T ptr) : _ptr(ptr) {
ARDUINOJSON_ASSERT(ptr != NULL); ARDUINOJSON_ASSERT(ptr != NULL);
} }
T get() const { T get() const {
ARDUINOJSON_ASSERT(_ptr != NULL); ARDUINOJSON_ASSERT(_ptr != NULL);
return _ptr; return _ptr;
} }
private: private:
T _ptr; T _ptr;
}; };
template <typename T> template <typename T>
not_null<T> make_not_null(T ptr) { not_null<T> make_not_null(T ptr) {
ARDUINOJSON_ASSERT(ptr != NULL); ARDUINOJSON_ASSERT(ptr != NULL);
return not_null<T>(ptr); return not_null<T>(ptr);
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

90
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/limits.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/limits.hpp
View File

@@ -1,45 +1,45 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include "type_traits.hpp" #include "type_traits.hpp"
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(push) #pragma warning(push)
#pragma warning(disable : 4310) #pragma warning(disable : 4310)
#endif #endif
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
// Differs from standard because we can't use the symbols "min" and "max" // Differs from standard because we can't use the symbols "min" and "max"
template <typename T, typename Enable = void> template <typename T, typename Enable = void>
struct numeric_limits; struct numeric_limits;
template <typename T> template <typename T>
struct numeric_limits<T, typename enable_if<is_unsigned<T>::value>::type> { struct numeric_limits<T, typename enable_if<is_unsigned<T>::value>::type> {
static T lowest() { static T lowest() {
return 0; return 0;
} }
static T highest() { static T highest() {
return T(-1); return T(-1);
} }
}; };
template <typename T> template <typename T>
struct numeric_limits< struct numeric_limits<
T, typename enable_if<is_integral<T>::value && is_signed<T>::value>::type> { T, typename enable_if<is_integral<T>::value && is_signed<T>::value>::type> {
static T lowest() { static T lowest() {
return T(T(1) << (sizeof(T) * 8 - 1)); return T(T(1) << (sizeof(T) * 8 - 1));
} }
static T highest() { static T highest() {
return T(~lowest()); return T(~lowest());
} }
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(pop) #pragma warning(pop)
#endif #endif

54
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/math.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/math.hpp
View File

@@ -1,27 +1,27 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
// Some libraries #define isnan() and isinf() so we need to check before // Some libraries #define isnan() and isinf() so we need to check before
// using this name // using this name
#ifndef isnan #ifndef isnan
template <typename T> template <typename T>
bool isnan(T x) { bool isnan(T x) {
return x != x; return x != x;
} }
#endif #endif
#ifndef isinf #ifndef isinf
template <typename T> template <typename T>
bool isinf(T x) { bool isinf(T x) {
return x != 0.0 && x * 2 == x; return x != 0.0 && x * 2 == x;
} }
#endif #endif
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

52
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/mpl/max.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/mpl/max.hpp
View File

@@ -1,26 +1,26 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
#include <stddef.h> // for size_t #include <stddef.h> // for size_t
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
// A meta-function that returns the highest value // A meta-function that returns the highest value
template <size_t X, size_t Y, bool MaxIsX = (X > Y)> template <size_t X, size_t Y, bool MaxIsX = (X > Y)>
struct Max {}; struct Max {};
template <size_t X, size_t Y> template <size_t X, size_t Y>
struct Max<X, Y, true> { struct Max<X, Y, true> {
static const size_t value = X; static const size_t value = X;
}; };
template <size_t X, size_t Y> template <size_t X, size_t Y>
struct Max<X, Y, false> { struct Max<X, Y, false> {
static const size_t value = Y; static const size_t value = Y;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

156
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/pgmspace.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/pgmspace.hpp
View File

@@ -1,78 +1,78 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
#include <ArduinoJson/Polyfills/assert.hpp> #include <ArduinoJson/Polyfills/assert.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
// Wraps a const char* so that the our functions are picked only if the // Wraps a const char* so that the our functions are picked only if the
// originals are missing // originals are missing
struct pgm_p { struct pgm_p {
pgm_p(const char* p) : address(p) {} pgm_p(const char* p) : address(p) {}
const char* address; const char* address;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE
#ifndef strlen_P #ifndef strlen_P
inline size_t strlen_P(ARDUINOJSON_NAMESPACE::pgm_p s) { inline size_t strlen_P(ARDUINOJSON_NAMESPACE::pgm_p s) {
const char* p = s.address; const char* p = s.address;
ARDUINOJSON_ASSERT(p != NULL); ARDUINOJSON_ASSERT(p != NULL);
while (pgm_read_byte(p)) p++; while (pgm_read_byte(p)) p++;
return size_t(p - s.address); return size_t(p - s.address);
} }
#endif #endif
#ifndef strncmp_P #ifndef strncmp_P
inline int strncmp_P(const char* a, ARDUINOJSON_NAMESPACE::pgm_p b, size_t n) { inline int strncmp_P(const char* a, ARDUINOJSON_NAMESPACE::pgm_p b, size_t n) {
const char* s1 = a; const char* s1 = a;
const char* s2 = b.address; const char* s2 = b.address;
ARDUINOJSON_ASSERT(s1 != NULL); ARDUINOJSON_ASSERT(s1 != NULL);
ARDUINOJSON_ASSERT(s2 != NULL); ARDUINOJSON_ASSERT(s2 != NULL);
while (n-- > 0) { while (n-- > 0) {
char c1 = *s1++; char c1 = *s1++;
char c2 = static_cast<char>(pgm_read_byte(s2++)); char c2 = static_cast<char>(pgm_read_byte(s2++));
if (c1 < c2) if (c1 < c2)
return -1; return -1;
if (c1 > c2) if (c1 > c2)
return 1; return 1;
if (c1 == 0 /* and c2 as well */) if (c1 == 0 /* and c2 as well */)
return 0; return 0;
} }
return 0; return 0;
} }
#endif #endif
#ifndef strcmp_P #ifndef strcmp_P
inline int strcmp_P(const char* a, ARDUINOJSON_NAMESPACE::pgm_p b) { inline int strcmp_P(const char* a, ARDUINOJSON_NAMESPACE::pgm_p b) {
const char* s1 = a; const char* s1 = a;
const char* s2 = b.address; const char* s2 = b.address;
ARDUINOJSON_ASSERT(s1 != NULL); ARDUINOJSON_ASSERT(s1 != NULL);
ARDUINOJSON_ASSERT(s2 != NULL); ARDUINOJSON_ASSERT(s2 != NULL);
for (;;) { for (;;) {
char c1 = *s1++; char c1 = *s1++;
char c2 = static_cast<char>(pgm_read_byte(s2++)); char c2 = static_cast<char>(pgm_read_byte(s2++));
if (c1 < c2) if (c1 < c2)
return -1; return -1;
if (c1 > c2) if (c1 > c2)
return 1; return 1;
if (c1 == 0 /* and c2 as well */) if (c1 == 0 /* and c2 as well */)
return 0; return 0;
} }
} }
#endif #endif
#ifndef memcpy_P #ifndef memcpy_P
inline void* memcpy_P(void* dst, ARDUINOJSON_NAMESPACE::pgm_p src, size_t n) { inline void* memcpy_P(void* dst, ARDUINOJSON_NAMESPACE::pgm_p src, size_t n) {
uint8_t* d = reinterpret_cast<uint8_t*>(dst); uint8_t* d = reinterpret_cast<uint8_t*>(dst);
const char* s = src.address; const char* s = src.address;
ARDUINOJSON_ASSERT(d != NULL); ARDUINOJSON_ASSERT(d != NULL);
ARDUINOJSON_ASSERT(s != NULL); ARDUINOJSON_ASSERT(s != NULL);
while (n-- > 0) { while (n-- > 0) {
*d++ = pgm_read_byte(s++); *d++ = pgm_read_byte(s++);
} }
return dst; return dst;
} }
#endif #endif

64
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/safe_strcmp.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/safe_strcmp.hpp
View File

@@ -1,32 +1,32 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
#include <stdint.h> // int8_t #include <stdint.h> // int8_t
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
inline int safe_strcmp(const char* a, const char* b) { inline int safe_strcmp(const char* a, const char* b) {
if (a == b) if (a == b)
return 0; return 0;
if (!a) if (!a)
return -1; return -1;
if (!b) if (!b)
return 1; return 1;
return strcmp(a, b); return strcmp(a, b);
} }
inline int safe_strncmp(const char* a, const char* b, size_t n) { inline int safe_strncmp(const char* a, const char* b, size_t n) {
if (a == b) if (a == b)
return 0; return 0;
if (!a) if (!a)
return -1; return -1;
if (!b) if (!b)
return 1; return 1;
return strncmp(a, b, n); return strncmp(a, b, n);
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

46
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/type_traits.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits.hpp
View File

@@ -1,23 +1,23 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include "type_traits/conditional.hpp" #include "type_traits/conditional.hpp"
#include "type_traits/enable_if.hpp" #include "type_traits/enable_if.hpp"
#include "type_traits/integral_constant.hpp" #include "type_traits/integral_constant.hpp"
#include "type_traits/is_array.hpp" #include "type_traits/is_array.hpp"
#include "type_traits/is_base_of.hpp" #include "type_traits/is_base_of.hpp"
#include "type_traits/is_class.hpp" #include "type_traits/is_class.hpp"
#include "type_traits/is_const.hpp" #include "type_traits/is_const.hpp"
#include "type_traits/is_convertible.hpp" #include "type_traits/is_convertible.hpp"
#include "type_traits/is_enum.hpp" #include "type_traits/is_enum.hpp"
#include "type_traits/is_floating_point.hpp" #include "type_traits/is_floating_point.hpp"
#include "type_traits/is_integral.hpp" #include "type_traits/is_integral.hpp"
#include "type_traits/is_same.hpp" #include "type_traits/is_same.hpp"
#include "type_traits/is_signed.hpp" #include "type_traits/is_signed.hpp"
#include "type_traits/is_unsigned.hpp" #include "type_traits/is_unsigned.hpp"
#include "type_traits/make_unsigned.hpp" #include "type_traits/make_unsigned.hpp"
#include "type_traits/remove_const.hpp" #include "type_traits/remove_const.hpp"
#include "type_traits/remove_reference.hpp" #include "type_traits/remove_reference.hpp"

40
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/conditional.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/conditional.hpp
View File

@@ -1,20 +1,20 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <bool Condition, class TrueType, class FalseType> template <bool Condition, class TrueType, class FalseType>
struct conditional { struct conditional {
typedef TrueType type; typedef TrueType type;
}; };
template <class TrueType, class FalseType> template <class TrueType, class FalseType>
struct conditional<false, TrueType, FalseType> { struct conditional<false, TrueType, FalseType> {
typedef FalseType type; typedef FalseType type;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

28
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/declval.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/declval.hpp
View File

@@ -1,14 +1,14 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename T> template <typename T>
T declval(); T declval();
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

38
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/enable_if.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/enable_if.hpp
View File

@@ -1,19 +1,19 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
// A meta-function that return the type T if Condition is true. // A meta-function that return the type T if Condition is true.
template <bool Condition, typename T = void> template <bool Condition, typename T = void>
struct enable_if {}; struct enable_if {};
template <typename T> template <typename T>
struct enable_if<true, T> { struct enable_if<true, T> {
typedef T type; typedef T type;
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

38
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/integral_constant.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/integral_constant.hpp
View File

@@ -1,19 +1,19 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename T, T v> template <typename T, T v>
struct integral_constant { struct integral_constant {
static const T value = v; static const T value = v;
}; };
typedef integral_constant<bool, true> true_type; typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type; typedef integral_constant<bool, false> false_type;
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

42
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_array.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_array.hpp
View File

@@ -1,21 +1,21 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
#include <stddef.h> // size_t #include <stddef.h> // size_t
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename T> template <typename T>
struct is_array : false_type {}; struct is_array : false_type {};
template <typename T> template <typename T>
struct is_array<T[]> : true_type {}; struct is_array<T[]> : true_type {};
template <typename T, size_t N> template <typename T, size_t N>
struct is_array<T[N]> : true_type {}; struct is_array<T[N]> : true_type {};
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

52
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_base_of.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_base_of.hpp
View File

@@ -1,26 +1,26 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include <ArduinoJson/Namespace.hpp> #include <ArduinoJson/Namespace.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
// A meta-function that returns true if Derived inherits from TBase is an // A meta-function that returns true if Derived inherits from TBase is an
// integral type. // integral type.
template <typename TBase, typename TDerived> template <typename TBase, typename TDerived>
class is_base_of { class is_base_of {
protected: // <- to avoid GCC's "all member functions in class are private" protected: // <- to avoid GCC's "all member functions in class are private"
typedef char Yes[1]; typedef char Yes[1];
typedef char No[2]; typedef char No[2];
static Yes &probe(const TBase *); static Yes &probe(const TBase *);
static No &probe(...); static No &probe(...);
public: public:
static const bool value = static const bool value =
sizeof(probe(reinterpret_cast<TDerived *>(0))) == sizeof(Yes); sizeof(probe(reinterpret_cast<TDerived *>(0))) == sizeof(Yes);
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

52
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_class.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_class.hpp
View File

@@ -1,26 +1,26 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include "declval.hpp" #include "declval.hpp"
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename T> template <typename T>
struct is_class { struct is_class {
protected: // <- to avoid GCC's "all member functions in class are private" protected: // <- to avoid GCC's "all member functions in class are private"
typedef char Yes[1]; typedef char Yes[1];
typedef char No[2]; typedef char No[2];
template <typename U> template <typename U>
static Yes &probe(void (U::*)(void)); static Yes &probe(void (U::*)(void));
template <typename> template <typename>
static No &probe(...); static No &probe(...);
public: public:
static const bool value = sizeof(probe<T>(0)) == sizeof(Yes); static const bool value = sizeof(probe<T>(0)) == sizeof(Yes);
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

34
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_const.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_const.hpp
View File

@@ -1,17 +1,17 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include "integral_constant.hpp" #include "integral_constant.hpp"
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
// A meta-function that return the type T without the const modifier // A meta-function that return the type T without the const modifier
template <typename T> template <typename T>
struct is_const : false_type {}; struct is_const : false_type {};
template <typename T> template <typename T>
struct is_const<const T> : true_type {}; struct is_const<const T> : true_type {};
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

77
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp
View File

@@ -1,34 +1,43 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include "declval.hpp" #include "declval.hpp"
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(push) #pragma warning(push)
// conversion from 'T' to 'To', possible loss of data // conversion from 'T' to 'To', possible loss of data
#pragma warning(disable : 4244) #pragma warning(disable : 4244)
#endif #endif
namespace ARDUINOJSON_NAMESPACE { #ifdef __ICCARM__
// Suppress IAR Compiler Warning[Pa093]: implicit conversion from floating point to integer
template <typename From, typename To> #pragma diag_suppress=Pa093
struct is_convertible { #endif
protected: // <- to avoid GCC's "all member functions in class are private"
typedef char Yes[1]; namespace ARDUINOJSON_NAMESPACE {
typedef char No[2];
template <typename From, typename To>
static Yes &probe(To); struct is_convertible {
static No &probe(...); protected: // <- to avoid GCC's "all member functions in class are private"
typedef char Yes[1];
public: typedef char No[2];
static const bool value = sizeof(probe(declval<From>())) == sizeof(Yes);
}; static Yes &probe(To);
static No &probe(...);
} // namespace ARDUINOJSON_NAMESPACE
public:
#ifdef _MSC_VER static const bool value = sizeof(probe(declval<From>())) == sizeof(Yes);
#pragma warning(pop) };
#endif
} // namespace ARDUINOJSON_NAMESPACE
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#ifdef __ICCARM__
#pragma diag_default=Pa093
#endif

45
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_enum.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_enum.hpp
View File

@@ -1,23 +1,22 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include "is_class.hpp" #include "is_class.hpp"
#include "is_convertible.hpp" #include "is_convertible.hpp"
#include "is_floating_point.hpp" #include "is_floating_point.hpp"
#include "is_integral.hpp" #include "is_integral.hpp"
#include "is_same.hpp" #include "is_same.hpp"
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename T> template <typename T>
struct is_enum { struct is_enum {
static const bool value = is_convertible<T, int>::value && static const bool value = is_convertible<T, int>::value &&
!is_class<T>::value && !is_integral<T>::value && !is_class<T>::value && !is_integral<T>::value &&
!is_floating_point<T>::value && !is_floating_point<T>::value;
!is_same<T, bool>::value; };
};
} // namespace ARDUINOJSON_NAMESPACE
} // namespace ARDUINOJSON_NAMESPACE

38
lib_standalone/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_floating_point.hpp → lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_floating_point.hpp
View File

@@ -1,19 +1,19 @@
// ArduinoJson - arduinojson.org // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2020 // Copyright Benoit Blanchon 2014-2020
// MIT License // MIT License
#pragma once #pragma once
#include "integral_constant.hpp" #include "integral_constant.hpp"
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <typename> template <typename>
struct is_floating_point : false_type {}; struct is_floating_point : false_type {};
template <> template <>
struct is_floating_point<float> : true_type {}; struct is_floating_point<float> : true_type {};
template <> template <>
struct is_floating_point<double> : true_type {}; struct is_floating_point<double> : true_type {};
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

Some files were not shown because too many files have changed in this diff Show More