├── .gitattributes ├── .gitignore ├── .pio ├── build │ ├── nodemcuv2 │ │ ├── lib676 │ │ │ ├── OneWire │ │ │ │ └── OneWire.cpp.o │ │ │ └── libOneWire.a │ │ ├── lib8a8 │ │ │ ├── DallasTemperature │ │ │ │ └── DallasTemperature.cpp.o │ │ │ └── libDallasTemperature.a │ │ └── libee8 │ │ │ ├── ESP8266HTTPClient │ │ │ └── ESP8266HTTPClient.cpp.o │ │ │ └── libESP8266HTTPClient.a │ └── project.checksum └── libdeps │ └── nodemcuv2 │ ├── ArduinoJson │ ├── .clang-format │ ├── .devcontainer │ │ ├── Dockerfile │ │ └── devcontainer.json │ ├── .gitattributes │ ├── .gitignore │ ├── .mbedignore │ ├── .piopm │ ├── .prettierignore │ ├── ArduinoJson.h │ ├── CHANGELOG.md │ ├── CMakeLists.txt │ ├── CONTRIBUTING.md │ ├── LICENSE.md │ ├── README.md │ ├── SUPPORT.md │ ├── appveyor.yml │ ├── banner.svg │ ├── component.mk │ ├── examples │ │ ├── JsonConfigFile │ │ │ └── JsonConfigFile.ino │ │ ├── JsonFilterExample │ │ │ └── JsonFilterExample.ino │ │ ├── JsonGeneratorExample │ │ │ └── JsonGeneratorExample.ino │ │ ├── JsonHttpClient │ │ │ └── JsonHttpClient.ino │ │ ├── JsonParserExample │ │ │ └── JsonParserExample.ino │ │ ├── JsonServer │ │ │ └── JsonServer.ino │ │ ├── JsonUdpBeacon │ │ │ └── JsonUdpBeacon.ino │ │ ├── MsgPackParser │ │ │ └── MsgPackParser.ino │ │ ├── ProgmemExample │ │ │ └── ProgmemExample.ino │ │ └── StringExample │ │ │ └── StringExample.ino │ ├── keywords.txt │ ├── library.json │ ├── library.properties │ └── src │ │ ├── ArduinoJson.h │ │ ├── ArduinoJson.hpp │ │ ├── ArduinoJson │ │ ├── Array │ │ │ ├── ArrayFunctions.hpp │ │ │ ├── ArrayImpl.hpp │ │ │ ├── ArrayIterator.hpp │ │ │ ├── ArrayRef.hpp │ │ │ ├── ArrayShortcuts.hpp │ │ │ ├── ElementProxy.hpp │ │ │ └── Utilities.hpp │ │ ├── Collection │ │ │ ├── CollectionData.hpp │ │ │ └── CollectionImpl.hpp │ │ ├── Configuration.hpp │ │ ├── Deserialization │ │ │ ├── DeserializationError.hpp │ │ │ ├── Filter.hpp │ │ │ ├── NestingLimit.hpp │ │ │ ├── Reader.hpp │ │ │ ├── Readers │ │ │ │ ├── ArduinoStreamReader.hpp │ │ │ │ ├── ArduinoStringReader.hpp │ │ │ │ ├── FlashReader.hpp │ │ │ │ ├── IteratorReader.hpp │ │ │ │ ├── RamReader.hpp │ │ │ │ ├── StdStreamReader.hpp │ │ │ │ └── VariantReader.hpp │ │ │ └── deserialize.hpp │ │ ├── Document │ │ │ ├── BasicJsonDocument.hpp │ │ │ ├── DynamicJsonDocument.hpp │ │ │ ├── JsonDocument.hpp │ │ │ └── StaticJsonDocument.hpp │ │ ├── Json │ │ │ ├── EscapeSequence.hpp │ │ │ ├── JsonDeserializer.hpp │ │ │ ├── JsonSerializer.hpp │ │ │ ├── Latch.hpp │ │ │ ├── PrettyJsonSerializer.hpp │ │ │ ├── TextFormatter.hpp │ │ │ ├── Utf16.hpp │ │ │ └── Utf8.hpp │ │ ├── Memory │ │ │ ├── Alignment.hpp │ │ │ └── MemoryPool.hpp │ │ ├── Misc │ │ │ ├── SerializedValue.hpp │ │ │ └── Visitable.hpp │ │ ├── MsgPack │ │ │ ├── MsgPackDeserializer.hpp │ │ │ ├── MsgPackSerializer.hpp │ │ │ ├── endianess.hpp │ │ │ └── ieee754.hpp │ │ ├── Namespace.hpp │ │ ├── Numbers │ │ │ ├── Float.hpp │ │ │ ├── FloatParts.hpp │ │ │ ├── FloatTraits.hpp │ │ │ ├── Integer.hpp │ │ │ ├── arithmeticCompare.hpp │ │ │ ├── convertNumber.hpp │ │ │ └── parseNumber.hpp │ │ ├── Object │ │ │ ├── MemberProxy.hpp │ │ │ ├── ObjectFunctions.hpp │ │ │ ├── ObjectImpl.hpp │ │ │ ├── ObjectIterator.hpp │ │ │ ├── ObjectRef.hpp │ │ │ ├── ObjectShortcuts.hpp │ │ │ └── Pair.hpp │ │ ├── Polyfills │ │ │ ├── alias_cast.hpp │ │ │ ├── assert.hpp │ │ │ ├── attributes.hpp │ │ │ ├── ctype.hpp │ │ │ ├── integer.hpp │ │ │ ├── limits.hpp │ │ │ ├── math.hpp │ │ │ ├── mpl │ │ │ │ └── max.hpp │ │ │ ├── pgmspace.hpp │ │ │ ├── pgmspace_generic.hpp │ │ │ ├── preprocessor.hpp │ │ │ ├── safe_strcmp.hpp │ │ │ ├── static_array.hpp │ │ │ ├── type_traits.hpp │ │ │ ├── type_traits │ │ │ │ ├── conditional.hpp │ │ │ │ ├── declval.hpp │ │ │ │ ├── enable_if.hpp │ │ │ │ ├── integral_constant.hpp │ │ │ │ ├── is_array.hpp │ │ │ │ ├── is_base_of.hpp │ │ │ │ ├── is_class.hpp │ │ │ │ ├── is_const.hpp │ │ │ │ ├── is_convertible.hpp │ │ │ │ ├── is_enum.hpp │ │ │ │ ├── is_floating_point.hpp │ │ │ │ ├── is_integral.hpp │ │ │ │ ├── is_pointer.hpp │ │ │ │ ├── is_same.hpp │ │ │ │ ├── is_signed.hpp │ │ │ │ ├── is_unsigned.hpp │ │ │ │ ├── make_unsigned.hpp │ │ │ │ ├── make_void.hpp │ │ │ │ ├── remove_const.hpp │ │ │ │ ├── remove_cv.hpp │ │ │ │ ├── remove_reference.hpp │ │ │ │ └── type_identity.hpp │ │ │ └── utility.hpp │ │ ├── Serialization │ │ │ ├── CountingDecorator.hpp │ │ │ ├── Writer.hpp │ │ │ ├── Writers │ │ │ │ ├── ArduinoStringWriter.hpp │ │ │ │ ├── DummyWriter.hpp │ │ │ │ ├── PrintWriter.hpp │ │ │ │ ├── StaticStringWriter.hpp │ │ │ │ ├── StdStreamWriter.hpp │ │ │ │ └── StdStringWriter.hpp │ │ │ ├── measure.hpp │ │ │ └── serialize.hpp │ │ ├── StringStorage │ │ │ ├── StringCopier.hpp │ │ │ ├── StringMover.hpp │ │ │ └── StringStorage.hpp │ │ ├── Strings │ │ │ ├── Adapters │ │ │ │ ├── ArduinoStringAdapter.hpp │ │ │ │ ├── ConstRamStringAdapter.hpp │ │ │ │ ├── FlashStringAdapter.hpp │ │ │ │ ├── JsonStringAdapter.hpp │ │ │ │ ├── RamStringAdapter.hpp │ │ │ │ ├── SizedFlashStringAdapter.hpp │ │ │ │ ├── SizedRamStringAdapter.hpp │ │ │ │ ├── StdStringAdapter.hpp │ │ │ │ └── StringViewAdapter.hpp │ │ │ ├── IsWriteableString.hpp │ │ │ ├── StoragePolicy.hpp │ │ │ ├── String.hpp │ │ │ ├── StringAdapter.hpp │ │ │ └── StringAdapters.hpp │ │ ├── Variant │ │ │ ├── Converter.hpp │ │ │ ├── ConverterImpl.hpp │ │ │ ├── SlotFunctions.hpp │ │ │ ├── VariantCompare.hpp │ │ │ ├── VariantContent.hpp │ │ │ ├── VariantData.hpp │ │ │ ├── VariantFunctions.hpp │ │ │ ├── VariantImpl.hpp │ │ │ ├── VariantOperators.hpp │ │ │ ├── VariantRef.hpp │ │ │ ├── VariantShortcuts.hpp │ │ │ ├── VariantSlot.hpp │ │ │ ├── VariantTag.hpp │ │ │ ├── VariantTo.hpp │ │ │ └── Visitor.hpp │ │ ├── compatibility.hpp │ │ └── version.hpp │ │ └── CMakeLists.txt │ ├── Button2 │ ├── .gitignore │ ├── .piopm │ ├── CHANGELOG.md │ ├── LICENSE │ ├── README.md │ ├── examples │ │ ├── LongpressHandler │ │ │ └── LongpressHandler.ino │ │ ├── MultiHandler │ │ │ └── MultiHandler.ino │ │ ├── MultipleButtons │ │ │ └── MultipleButtons.ino │ │ ├── SingleButton │ │ │ └── SingleButton.ino │ │ └── SingleButtonSimple │ │ │ └── SingleButtonSimple.ino │ ├── keywords.txt │ ├── library.json │ ├── library.properties │ └── src │ │ ├── Button2.cpp │ │ └── Button2.h │ ├── DallasTemperature │ ├── .gitignore │ ├── .piopm │ ├── DallasTemperature.cpp │ ├── DallasTemperature.h │ ├── README.md │ ├── examples │ │ ├── Alarm │ │ │ └── Alarm.ino │ │ ├── AlarmHandler │ │ │ └── AlarmHandler.ino │ │ ├── ExternalPullup │ │ │ └── ExternalPullup.ino │ │ ├── Multibus_simple │ │ │ └── Multibus_simple.ino │ │ ├── Multiple │ │ │ └── Multiple.ino │ │ ├── SaveRecallScratchPad │ │ │ └── SaveRecallScratchPad.ino │ │ ├── SetUserData │ │ │ └── SetUserData.ino │ │ ├── Simple │ │ │ └── Simple.ino │ │ ├── Single │ │ │ └── Single.ino │ │ ├── Tester │ │ │ └── Tester.ino │ │ ├── Timing │ │ │ └── Timing.ino │ │ ├── TwoPin_DS18B20 │ │ │ └── TwoPin_DS18B20.ino │ │ ├── UserDataDemo │ │ │ └── UserDataDemo.ino │ │ ├── UserDataWriteBatch │ │ │ └── UserDataWriteBatch.ino │ │ ├── WaitForConversion │ │ │ └── WaitForConversion.ino │ │ ├── WaitForConversion2 │ │ │ └── WaitForConversion2.ino │ │ ├── oneWireSearch │ │ │ └── oneWireSearch.ino │ │ └── readPowerSupply │ │ │ └── readPowerSupply.ino │ ├── keywords.txt │ ├── library.json │ └── library.properties │ ├── OneWire │ ├── .piopm │ ├── OneWire.cpp │ ├── OneWire.h │ ├── docs │ │ └── issue_template.md │ ├── examples │ │ ├── DS18x20_Temperature │ │ │ └── DS18x20_Temperature.pde │ │ ├── DS2408_Switch │ │ │ └── DS2408_Switch.pde │ │ └── DS250x_PROM │ │ │ └── DS250x_PROM.pde │ ├── keywords.txt │ ├── library.json │ ├── library.properties │ └── util │ │ ├── OneWire_direct_gpio.h │ │ └── OneWire_direct_regtype.h │ ├── Time │ ├── .piopm │ ├── DateStrings.cpp │ ├── Readme.md │ ├── Time.cpp │ ├── Time.h │ ├── TimeLib.h │ ├── docs │ │ └── issue_template.md │ ├── examples │ │ ├── Processing │ │ │ └── SyncArduinoClock │ │ │ │ ├── SyncArduinoClock.pde │ │ │ │ └── readme.txt │ │ ├── TimeArduinoDue │ │ │ └── TimeArduinoDue.ino │ │ ├── TimeGPS │ │ │ └── TimeGPS.ino │ │ ├── TimeNTP │ │ │ └── TimeNTP.ino │ │ ├── TimeNTP_ENC28J60 │ │ │ └── TimeNTP_ENC28J60.ino │ │ ├── TimeNTP_ESP8266WiFi │ │ │ └── TimeNTP_ESP8266WiFi.ino │ │ ├── TimeRTC │ │ │ └── TimeRTC.ino │ │ ├── TimeRTCLog │ │ │ └── TimeRTCLog.ino │ │ ├── TimeRTCSet │ │ │ └── TimeRTCSet.ino │ │ ├── TimeSerial │ │ │ └── TimeSerial.ino │ │ ├── TimeSerialDateStrings │ │ │ └── TimeSerialDateStrings.ino │ │ └── TimeTeensy3 │ │ │ └── TimeTeensy3.ino │ ├── keywords.txt │ ├── library.json │ └── library.properties │ ├── Timezone │ ├── .piopm │ ├── CONTRIBUTING.md │ ├── LICENSE.md │ ├── README.md │ ├── examples │ │ ├── Change_TZ_1 │ │ │ └── Change_TZ_1.ino │ │ ├── Change_TZ_2 │ │ │ └── Change_TZ_2.ino │ │ ├── Clock │ │ │ └── Clock.ino │ │ ├── HardwareRTC │ │ │ └── HardwareRTC.ino │ │ ├── WorldClock │ │ │ └── WorldClock.ino │ │ ├── WriteRules │ │ │ └── WriteRules.ino │ │ └── tzTest │ │ │ └── tzTest.ino │ ├── keywords.txt │ ├── library.properties │ └── src │ │ ├── Timezone.cpp │ │ └── Timezone.h │ ├── U8g2 │ ├── .piopm │ ├── LICENSE │ ├── README.md │ ├── examples │ │ ├── full_buffer │ │ │ ├── FPS │ │ │ │ └── FPS.ino │ │ │ ├── FontUsage │ │ │ │ └── FontUsage.ino │ │ │ ├── GraphicsTest │ │ │ │ └── GraphicsTest.ino │ │ │ ├── HelloWorld │ │ │ │ └── HelloWorld.ino │ │ │ ├── IconMenu │ │ │ │ └── IconMenu.ino │ │ │ ├── PrintUTF8 │ │ │ │ └── PrintUTF8.ino │ │ │ ├── ScreenShot │ │ │ │ └── ScreenShot.ino │ │ │ ├── SelectionList │ │ │ │ └── SelectionList.ino │ │ │ ├── Shennong │ │ │ │ └── Shennong.ino │ │ │ ├── U8g2Logo │ │ │ │ └── U8g2Logo.ino │ │ │ ├── UpdateArea │ │ │ │ └── UpdateArea.ino │ │ │ └── Weather │ │ │ │ └── Weather.ino │ │ ├── games │ │ │ ├── LittleRookChess │ │ │ │ └── LittleRookChess.ino │ │ │ └── SpaceTrash │ │ │ │ └── SpaceTrash.ino │ │ ├── page_buffer │ │ │ ├── A2Printer │ │ │ │ └── A2Printer.ino │ │ │ ├── Chinese │ │ │ │ └── Chinese.ino │ │ │ ├── ClipWindow │ │ │ │ └── ClipWindow.ino │ │ │ ├── Clock │ │ │ │ └── Clock.ino │ │ │ ├── ContrastTest │ │ │ │ └── ContrastTest.ino │ │ │ ├── Devanagari │ │ │ │ └── Devanagari.ino │ │ │ ├── DirectAccess │ │ │ │ └── DirectAccess.ino │ │ │ ├── DrawLog │ │ │ │ └── DrawLog.ino │ │ │ ├── ExtUTF8 │ │ │ │ └── ExtUTF8.ino │ │ │ ├── FPS │ │ │ │ └── FPS.ino │ │ │ ├── FlipMode │ │ │ │ └── FlipMode.ino │ │ │ ├── GraphicsTest │ │ │ │ └── GraphicsTest.ino │ │ │ ├── HelloWorld │ │ │ │ └── HelloWorld.ino │ │ │ ├── IconMenu │ │ │ │ └── IconMenu.ino │ │ │ ├── Japanese │ │ │ │ └── Japanese.ino │ │ │ ├── Korean │ │ │ │ └── Korean.ino │ │ │ ├── LoadFromSD │ │ │ │ └── LoadFromSD.ino │ │ │ ├── PowerSaveTest │ │ │ │ └── PowerSaveTest.ino │ │ │ ├── PrintHelloWorld │ │ │ │ └── PrintHelloWorld.ino │ │ │ ├── PrintProgmem │ │ │ │ └── PrintProgmem.ino │ │ │ ├── PrintUTF8 │ │ │ │ └── PrintUTF8.ino │ │ │ ├── ScrollingText │ │ │ │ └── ScrollingText.ino │ │ │ ├── SelectionList │ │ │ │ └── SelectionList.ino │ │ │ ├── Serial │ │ │ │ └── Serial.ino │ │ │ ├── Shennong │ │ │ │ └── Shennong.ino │ │ │ ├── StateBufferLoop │ │ │ │ └── StateBufferLoop.ino │ │ │ ├── Terminal │ │ │ │ └── Terminal.ino │ │ │ ├── U8g2Logo │ │ │ │ └── U8g2Logo.ino │ │ │ ├── UpdatePartly │ │ │ │ └── UpdatePartly.ino │ │ │ ├── Weather │ │ │ │ └── Weather.ino │ │ │ ├── XBM │ │ │ │ └── XBM.ino │ │ │ └── XORTest │ │ │ │ └── XORTest.ino │ │ └── u8x8 │ │ │ ├── 16x16Font │ │ │ └── 16x16Font.ino │ │ │ ├── ArduboyTest │ │ │ └── ArduboyTest.ino │ │ │ ├── FlipMode │ │ │ └── FlipMode.ino │ │ │ ├── GraphicsTest │ │ │ └── GraphicsTest.ino │ │ │ ├── HelloWorld │ │ │ └── HelloWorld.ino │ │ │ ├── MessageBox │ │ │ └── MessageBox.ino │ │ │ └── Terminal │ │ │ └── Terminal.ino │ ├── keywords.txt │ ├── library.properties │ └── src │ │ ├── U8g2lib.cpp │ │ ├── U8g2lib.h │ │ ├── U8x8lib.cpp │ │ ├── U8x8lib.h │ │ └── clib │ │ ├── u8g2.h │ │ ├── u8g2_bitmap.c │ │ ├── u8g2_box.c │ │ ├── u8g2_buffer.c │ │ ├── u8g2_circle.c │ │ ├── u8g2_cleardisplay.c │ │ ├── u8g2_d_memory.c │ │ ├── u8g2_d_setup.c │ │ ├── u8g2_font.c │ │ ├── u8g2_fonts.c │ │ ├── u8g2_hvline.c │ │ ├── u8g2_input_value.c │ │ ├── u8g2_intersection.c │ │ ├── u8g2_kerning.c │ │ ├── u8g2_line.c │ │ ├── u8g2_ll_hvline.c │ │ ├── u8g2_message.c │ │ ├── u8g2_polygon.c │ │ ├── u8g2_selection_list.c │ │ ├── u8g2_setup.c │ │ ├── u8log.c │ │ ├── u8log_u8g2.c │ │ ├── u8log_u8x8.c │ │ ├── u8x8.h │ │ ├── u8x8_8x8.c │ │ ├── u8x8_byte.c │ │ ├── u8x8_cad.c │ │ ├── u8x8_capture.c │ │ ├── u8x8_d_a2printer.c │ │ ├── u8x8_d_il3820_296x128.c │ │ ├── u8x8_d_ist3020.c │ │ ├── u8x8_d_ist7920.c │ │ ├── u8x8_d_ks0108.c │ │ ├── u8x8_d_lc7981.c │ │ ├── u8x8_d_ld7032_60x32.c │ │ ├── u8x8_d_ls013b7dh03.c │ │ ├── u8x8_d_max7219.c │ │ ├── u8x8_d_pcd8544_84x48.c │ │ ├── u8x8_d_pcf8812.c │ │ ├── u8x8_d_pcf8814_hx1230.c │ │ ├── u8x8_d_sbn1661.c │ │ ├── u8x8_d_sed1330.c │ │ ├── u8x8_d_sh1106_64x32.c │ │ ├── u8x8_d_sh1106_72x40.c │ │ ├── u8x8_d_sh1107.c │ │ ├── u8x8_d_sh1108.c │ │ ├── u8x8_d_sh1122.c │ │ ├── u8x8_d_ssd1305.c │ │ ├── u8x8_d_ssd1306_128x32.c │ │ ├── u8x8_d_ssd1306_128x64_noname.c │ │ ├── u8x8_d_ssd1306_2040x16.c │ │ ├── u8x8_d_ssd1306_48x64.c │ │ ├── u8x8_d_ssd1306_64x32.c │ │ ├── u8x8_d_ssd1306_64x48.c │ │ ├── u8x8_d_ssd1306_72x40.c │ │ ├── u8x8_d_ssd1306_96x16.c │ │ ├── u8x8_d_ssd1309.c │ │ ├── u8x8_d_ssd1316.c │ │ ├── u8x8_d_ssd1317.c │ │ ├── u8x8_d_ssd1318.c │ │ ├── u8x8_d_ssd1322.c │ │ ├── u8x8_d_ssd1325.c │ │ ├── u8x8_d_ssd1326.c │ │ ├── u8x8_d_ssd1327.c │ │ ├── u8x8_d_ssd1329.c │ │ ├── u8x8_d_ssd1606_172x72.c │ │ ├── u8x8_d_ssd1607_200x200.c │ │ ├── u8x8_d_st7511.c │ │ ├── u8x8_d_st75256.c │ │ ├── u8x8_d_st7528.c │ │ ├── u8x8_d_st75320.c │ │ ├── u8x8_d_st7565.c │ │ ├── u8x8_d_st7567.c │ │ ├── u8x8_d_st7586s_erc240160.c │ │ ├── u8x8_d_st7586s_s028hn118a.c │ │ ├── u8x8_d_st7588.c │ │ ├── u8x8_d_st7920.c │ │ ├── u8x8_d_t6963.c │ │ ├── u8x8_d_uc1601.c │ │ ├── u8x8_d_uc1604.c │ │ ├── u8x8_d_uc1608.c │ │ ├── u8x8_d_uc1610.c │ │ ├── u8x8_d_uc1611.c │ │ ├── u8x8_d_uc1617.c │ │ ├── u8x8_d_uc1638.c │ │ ├── u8x8_d_uc1701_dogs102.c │ │ ├── u8x8_d_uc1701_mini12864.c │ │ ├── u8x8_debounce.c │ │ ├── u8x8_display.c │ │ ├── u8x8_fonts.c │ │ ├── u8x8_gpio.c │ │ ├── u8x8_input_value.c │ │ ├── u8x8_message.c │ │ ├── u8x8_selection_list.c │ │ ├── u8x8_setup.c │ │ ├── u8x8_string.c │ │ ├── u8x8_u16toa.c │ │ └── u8x8_u8toa.c │ └── WiFiManager │ ├── .github │ ├── CONTRIBUTING.md │ └── ISSUE_TEMPLATE.md │ ├── .piopm │ ├── .travis.yml │ ├── LICENSE │ ├── README.md │ ├── WiFiManager.cpp │ ├── WiFiManager.h │ ├── examples │ ├── AutoConnect │ │ └── AutoConnect.ino │ ├── AutoConnectWithFSParameters │ │ └── AutoConnectWithFSParameters.ino │ ├── AutoConnectWithFSParametersAndCustomIP │ │ └── AutoConnectWithFSParametersAndCustomIP.ino │ ├── AutoConnectWithFeedback │ │ └── AutoConnectWithFeedback.ino │ ├── AutoConnectWithFeedbackLED │ │ └── AutoConnectWithFeedbackLED.ino │ ├── AutoConnectWithReset │ │ └── AutoConnectWithReset.ino │ ├── AutoConnectWithStaticIP │ │ └── AutoConnectWithStaticIP.ino │ ├── AutoConnectWithTimeout │ │ └── AutoConnectWithTimeout.ino │ └── OnDemandConfigPortal │ │ └── OnDemandConfigPortal.ino │ ├── extras │ └── template.h │ ├── keywords.txt │ ├── library.json │ ├── library.properties │ └── travis │ └── common.sh ├── .vscode └── extensions.json ├── README.md ├── img ├── EpaperThingImg.JPG └── 微雪2.9寸墨水屏坐标系参考.jpg ├── include └── README ├── lib └── README ├── platformio.ini ├── src ├── NTP.h └── main.cpp └── test └── README /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | -------------------------------------------------------------------------------- /.pio/build/nodemcuv2/lib676/OneWire/OneWire.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/88431844/EpaperThing/84022efb7c1cb82073e001623102359cbff49817/.pio/build/nodemcuv2/lib676/OneWire/OneWire.cpp.o -------------------------------------------------------------------------------- /.pio/build/nodemcuv2/lib676/libOneWire.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/88431844/EpaperThing/84022efb7c1cb82073e001623102359cbff49817/.pio/build/nodemcuv2/lib676/libOneWire.a -------------------------------------------------------------------------------- /.pio/build/nodemcuv2/lib8a8/DallasTemperature/DallasTemperature.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/88431844/EpaperThing/84022efb7c1cb82073e001623102359cbff49817/.pio/build/nodemcuv2/lib8a8/DallasTemperature/DallasTemperature.cpp.o -------------------------------------------------------------------------------- /.pio/build/nodemcuv2/lib8a8/libDallasTemperature.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/88431844/EpaperThing/84022efb7c1cb82073e001623102359cbff49817/.pio/build/nodemcuv2/lib8a8/libDallasTemperature.a -------------------------------------------------------------------------------- /.pio/build/nodemcuv2/libee8/ESP8266HTTPClient/ESP8266HTTPClient.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/88431844/EpaperThing/84022efb7c1cb82073e001623102359cbff49817/.pio/build/nodemcuv2/libee8/ESP8266HTTPClient/ESP8266HTTPClient.cpp.o -------------------------------------------------------------------------------- /.pio/build/nodemcuv2/libee8/libESP8266HTTPClient.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/88431844/EpaperThing/84022efb7c1cb82073e001623102359cbff49817/.pio/build/nodemcuv2/libee8/libESP8266HTTPClient.a -------------------------------------------------------------------------------- /.pio/build/project.checksum: -------------------------------------------------------------------------------- 1 | fe8ab232e81fbe104609787ec9e50740fc4af5f4 -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/.clang-format: -------------------------------------------------------------------------------- 1 | # http://clang.llvm.org/docs/ClangFormatStyleOptions.html 2 | 3 | BasedOnStyle: Google 4 | Standard: Cpp03 5 | AllowShortFunctionsOnASingleLine: Empty 6 | IncludeBlocks: Preserve 7 | IndentPPDirectives: AfterHash 8 | 9 | # Always break after if to get accurate coverage 10 | AllowShortIfStatementsOnASingleLine: false 11 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/.devcontainer/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM ubuntu:20.04 2 | 3 | RUN apt-get update && \ 4 | apt-get install -y software-properties-common curl && \ 5 | apt-get upgrade -y 6 | RUN apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 15CF4D18AF4F7421 7 | RUN add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ trusty main' && \ 8 | add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ trusty universe' && \ 9 | add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ xenial main' && \ 10 | add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ xenial universe' && \ 11 | add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ bionic main' && \ 12 | add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ bionic universe' && \ 13 | add-apt-repository -yn 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-6.0 main' && \ 14 | add-apt-repository -yn 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-7 main' && \ 15 | add-apt-repository -yn 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-8 main' && \ 16 | add-apt-repository -yn 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main' && \ 17 | add-apt-repository -yn 'deb http://mirrors.kernel.org/ubuntu hirsute main universe' 18 | 19 | RUN apt-get update && apt-get -y install \ 20 | cmake \ 21 | ninja-build \ 22 | git \ 23 | clang-format \ 24 | g++-4.4 \ 25 | g++-4.6 \ 26 | g++-4.7 \ 27 | g++-4.8 \ 28 | g++-4.9 \ 29 | g++-5 \ 30 | g++-7 \ 31 | g++-8 \ 32 | g++-9 \ 33 | g++-10 \ 34 | g++-11 \ 35 | clang-3.5 \ 36 | clang-3.6 \ 37 | clang-3.7 \ 38 | clang-3.8 \ 39 | clang-3.9 \ 40 | clang-6.0 \ 41 | clang-7 \ 42 | clang-8 \ 43 | clang-9 \ 44 | clang-10 \ 45 | clang-11 46 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/.devcontainer/devcontainer.json: -------------------------------------------------------------------------------- 1 | // For format details, see https://aka.ms/devcontainer.json. For config options, see the README at: 2 | // https://github.com/microsoft/vscode-dev-containers/tree/v0.183.0/containers/ubuntu 3 | { 4 | "name": "Ubuntu", 5 | "build": { 6 | "dockerfile": "Dockerfile" 7 | }, 8 | 9 | // Set *default* container specific settings.json values on container create. 10 | "settings": {}, 11 | 12 | // Add the IDs of extensions you want installed when the container is created. 13 | "extensions": [ 14 | "ms-vscode.cmake-tools", 15 | "ms-vscode.cpptools", 16 | "xaver.clang-format" 17 | ], 18 | 19 | // Use 'forwardPorts' to make a list of ports inside the container available locally. 20 | // "forwardPorts": [], 21 | 22 | // Use 'postCreateCommand' to run commands after the container is created. 23 | // "postCreateCommand": "uname -a", 24 | } 25 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/.gitattributes: -------------------------------------------------------------------------------- 1 | *.sh text eol=lf -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | /.idea 3 | /build 4 | /bin 5 | /lib 6 | /sftp-config.json 7 | .tags 8 | .tags_sorted_by_file 9 | /extras/fuzzing/*_fuzzer 10 | /extras/fuzzing/*_fuzzer.options 11 | /extras/fuzzing/*_fuzzer_seed_corpus.zip 12 | .vs/ 13 | 14 | # Used by CI for Particle 15 | /src/*.ino 16 | /project.properties 17 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/.mbedignore: -------------------------------------------------------------------------------- 1 | .github/ 2 | examples/ 3 | extras/ -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/.piopm: -------------------------------------------------------------------------------- 1 | {"type": "library", "name": "ArduinoJson", "version": "6.18.4", "spec": {"owner": "bblanchon", "id": 64, "name": "ArduinoJson", "requirements": null, "url": null}} -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/.prettierignore: -------------------------------------------------------------------------------- 1 | *.md 2 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/ArduinoJson.h: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #include "src/ArduinoJson.h" 6 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - https://arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2021 3 | # MIT License 4 | 5 | cmake_minimum_required(VERSION 3.3) 6 | 7 | if(ESP_PLATFORM) 8 | # Build ArduinoJson as an ESP-IDF component 9 | idf_component_register(INCLUDE_DIRS src) 10 | target_compile_definitions(${COMPONENT_LIB} INTERFACE ARDUINOJSON_EMBEDDED_MODE=1) 11 | return() 12 | endif() 13 | 14 | project(ArduinoJson VERSION 6.18.4) 15 | 16 | if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME) 17 | include(CTest) 18 | endif() 19 | 20 | add_subdirectory(src) 21 | 22 | if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_TESTING) 23 | include(extras/CompileOptions.cmake) 24 | add_subdirectory(extras/tests) 25 | add_subdirectory(extras/fuzzing) 26 | endif() 27 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contribution to ArduinoJson 2 | 3 | First, thank you for taking the time to contribute to this project. 4 | 5 | You can submit changes via GitHub Pull Requests. 6 | 7 | Please: 8 | 9 | 1. Update the test suite for any change of behavior 10 | 2. Use clang-format in "file" mode to format the code 11 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/LICENSE.md: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | --------------------- 3 | 4 | Copyright © 2014-2021 Benoit BLANCHON 5 | 6 | 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: 7 | 8 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 9 | 10 | 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. 11 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/SUPPORT.md: -------------------------------------------------------------------------------- 1 | # ArduinoJson Support 2 | 3 | First off, thank you very much for using ArduinoJson. 4 | 5 | We'll be very happy to help you, but first please read the following. 6 | 7 | ## Before asking for help 8 | 9 | 1. Read the [FAQ](https://arduinojson.org/faq/?utm_source=github&utm_medium=support) 10 | 2. Search in the [API Reference](https://arduinojson.org/api/?utm_source=github&utm_medium=support) 11 | 12 | If you did not find the answer, please create a [new issue on GitHub](https://github.com/bblanchon/ArduinoJson/issues/new). 13 | 14 | It is OK to add a comment to a currently opened issue, but please avoid adding comments to a closed issue. 15 | 16 | ## Before hitting the Submit button 17 | 18 | Please provide all the relevant information: 19 | 20 | * Good title 21 | * Short description of the problem 22 | * Target platform 23 | * Compiler model and version 24 | * [MVCE](https://stackoverflow.com/help/mcve) 25 | * Compiler output 26 | 27 | Good questions get fast answers! 28 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: 6.18.4.{build} 2 | environment: 3 | matrix: 4 | - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019 5 | CMAKE_GENERATOR: Visual Studio 16 2019 6 | - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 7 | CMAKE_GENERATOR: Visual Studio 15 2017 8 | - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015 9 | CMAKE_GENERATOR: Visual Studio 14 2015 10 | - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013 11 | CMAKE_GENERATOR: Visual Studio 12 2013 12 | - CMAKE_GENERATOR: Visual Studio 11 2012 13 | - CMAKE_GENERATOR: Visual Studio 10 2010 14 | - CMAKE_GENERATOR: MinGW Makefiles 15 | configuration: Debug 16 | before_build: 17 | - set PATH=C:\MinGW\bin;%PATH:C:\Program Files\Git\usr\bin;=% # Workaround for CMake not wanting sh.exe on PATH for MinGW 18 | - cmake -DCMAKE_BUILD_TYPE=%CONFIGURATION% -G "%CMAKE_GENERATOR%" . 19 | build_script: 20 | - cmake --build . --config %CONFIGURATION% 21 | test_script: 22 | - ctest -C %CONFIGURATION% --output-on-failure . 23 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/component.mk: -------------------------------------------------------------------------------- 1 | COMPONENT_ADD_INCLUDEDIRS := src 2 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/keywords.txt: -------------------------------------------------------------------------------- 1 | # Macros 2 | JSON_ARRAY_SIZE KEYWORD2 3 | JSON_OBJECT_SIZE KEYWORD2 4 | JSON_STRING_SIZE KEYWORD2 5 | 6 | # Free functions 7 | deserializeJson KEYWORD2 8 | deserializeMsgPack KEYWORD2 9 | serialized KEYWORD2 10 | serializeJson KEYWORD2 11 | serializeJsonPretty KEYWORD2 12 | serializeMsgPack KEYWORD2 13 | measureJson KEYWORD2 14 | measureJsonPretty KEYWORD2 15 | measureMsgPack KEYWORD2 16 | 17 | # Methods 18 | add KEYWORD2 19 | as KEYWORD2 20 | createNestedArray KEYWORD2 21 | createNestedObject KEYWORD2 22 | get KEYWORD2 23 | set KEYWORD2 24 | to KEYWORD2 25 | 26 | # Type names 27 | DeserializationError KEYWORD1 DATA_TYPE 28 | DynamicJsonDocument KEYWORD1 DATA_TYPE 29 | JsonArray KEYWORD1 DATA_TYPE 30 | JsonArrayConst KEYWORD1 DATA_TYPE 31 | JsonDocument KEYWORD1 DATA_TYPE 32 | JsonFloat KEYWORD1 DATA_TYPE 33 | JsonInteger KEYWORD1 DATA_TYPE 34 | JsonObject KEYWORD1 DATA_TYPE 35 | JsonObjectConst KEYWORD1 DATA_TYPE 36 | JsonString KEYWORD1 DATA_TYPE 37 | JsonUInt KEYWORD1 DATA_TYPE 38 | JsonVariant KEYWORD1 DATA_TYPE 39 | JsonVariantConst KEYWORD1 DATA_TYPE 40 | StaticJsonDocument KEYWORD1 DATA_TYPE 41 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/library.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "ArduinoJson", 3 | "keywords": "json, rest, http, web", 4 | "description": "A simple and efficient JSON library for embedded C++. 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.", 5 | "homepage": "https://arduinojson.org/?utm_source=meta&utm_medium=library.json", 6 | "repository": { 7 | "type": "git", 8 | "url": "https://github.com/bblanchon/ArduinoJson.git" 9 | }, 10 | "version": "6.18.4", 11 | "authors": { 12 | "name": "Benoit Blanchon", 13 | "url": "https://blog.benoitblanchon.fr" 14 | }, 15 | "exclude": [ 16 | ".github", 17 | "extras" 18 | ], 19 | "frameworks": "*", 20 | "platforms": "*", 21 | "build": { 22 | "libArchive": false 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/library.properties: -------------------------------------------------------------------------------- 1 | name=ArduinoJson 2 | version=6.18.4 3 | author=Benoit Blanchon 4 | maintainer=Benoit Blanchon 5 | sentence=A simple and efficient JSON library for embedded C++. 6 | 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. 7 | category=Data Processing 8 | url=https://arduinojson.org/?utm_source=meta&utm_medium=library.properties 9 | architectures=* 10 | repository=https://github.com/bblanchon/ArduinoJson.git 11 | license=MIT 12 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson.h: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #ifdef __cplusplus 8 | 9 | #include "ArduinoJson.hpp" 10 | 11 | using namespace ArduinoJson; 12 | 13 | #else 14 | 15 | #error ArduinoJson requires a C++ compiler, please change file extension to .cc or .cpp 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Array/ArrayFunctions.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | inline VariantData *arrayAdd(CollectionData *arr, MemoryPool *pool) { 12 | return arr ? arr->addElement(pool) : 0; 13 | } 14 | 15 | template 16 | inline typename TVisitor::result_type arrayAccept(const CollectionData *arr, 17 | TVisitor &visitor) { 18 | if (arr) 19 | return visitor.visitArray(*arr); 20 | else 21 | return visitor.visitNull(); 22 | } 23 | 24 | inline bool arrayEquals(const CollectionData *lhs, const CollectionData *rhs) { 25 | if (lhs == rhs) 26 | return true; 27 | if (!lhs || !rhs) 28 | return false; 29 | return lhs->equalsArray(*rhs); 30 | } 31 | } // namespace ARDUINOJSON_NAMESPACE 32 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Array/ArrayImpl.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | template 13 | inline ArrayRef ArrayShortcuts::createNestedArray() const { 14 | return impl()->addElement().template to(); 15 | } 16 | 17 | template 18 | inline ObjectRef ArrayShortcuts::createNestedObject() const { 19 | return impl()->addElement().template to(); 20 | } 21 | 22 | template 23 | inline ElementProxy ArrayShortcuts::operator[]( 24 | size_t index) const { 25 | return ElementProxy(*impl(), index); 26 | } 27 | 28 | } // namespace ARDUINOJSON_NAMESPACE 29 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Array/ArrayShortcuts.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | // Forward declarations. 12 | class ArrayRef; 13 | class ObjectRef; 14 | template 15 | class ElementProxy; 16 | 17 | template 18 | class ArrayShortcuts { 19 | public: 20 | // Returns the element at specified index if the variant is an array. 21 | FORCE_INLINE ElementProxy operator[](size_t index) const; 22 | 23 | FORCE_INLINE ObjectRef createNestedObject() const; 24 | 25 | FORCE_INLINE ArrayRef createNestedArray() const; 26 | 27 | // Adds the specified value at the end of the array. 28 | // 29 | // bool add(TValue); 30 | // TValue = bool, long, int, short, float, double, serialized, VariantRef, 31 | // std::string, String, ObjectRef 32 | template 33 | FORCE_INLINE bool add(const T &value) const { 34 | return impl()->addElement().set(value); 35 | } 36 | // 37 | // bool add(TValue); 38 | // TValue = char*, const char*, const __FlashStringHelper* 39 | template 40 | FORCE_INLINE bool add(T *value) const { 41 | return impl()->addElement().set(value); 42 | } 43 | 44 | private: 45 | const TArray *impl() const { 46 | return static_cast(this); 47 | } 48 | }; 49 | } // namespace ARDUINOJSON_NAMESPACE 50 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Collection/CollectionData.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | #include // size_t 11 | 12 | namespace ARDUINOJSON_NAMESPACE { 13 | 14 | class MemoryPool; 15 | class VariantData; 16 | class VariantSlot; 17 | 18 | class CollectionData { 19 | VariantSlot *_head; 20 | VariantSlot *_tail; 21 | 22 | public: 23 | // Must be a POD! 24 | // - no constructor 25 | // - no destructor 26 | // - no virtual 27 | // - no inheritance 28 | 29 | // Array only 30 | 31 | VariantData *addElement(MemoryPool *pool); 32 | 33 | VariantData *getElement(size_t index) const; 34 | 35 | VariantData *getOrAddElement(size_t index, MemoryPool *pool); 36 | 37 | void removeElement(size_t index); 38 | 39 | bool equalsArray(const CollectionData &other) const; 40 | 41 | // Object only 42 | 43 | template 44 | VariantData *addMember(TAdaptedString key, MemoryPool *pool); 45 | 46 | template 47 | VariantData *getMember(TAdaptedString key) const; 48 | 49 | template 50 | VariantData *getOrAddMember(TAdaptedString key, MemoryPool *pool); 51 | 52 | template 53 | void removeMember(TAdaptedString key) { 54 | removeSlot(getSlot(key)); 55 | } 56 | 57 | template 58 | bool containsKey(const TAdaptedString &key) const; 59 | 60 | bool equalsObject(const CollectionData &other) const; 61 | 62 | // Generic 63 | 64 | void clear(); 65 | size_t memoryUsage() const; 66 | size_t nesting() const; 67 | size_t size() const; 68 | 69 | VariantSlot *addSlot(MemoryPool *); 70 | void removeSlot(VariantSlot *slot); 71 | 72 | bool copyFrom(const CollectionData &src, MemoryPool *pool); 73 | 74 | VariantSlot *head() const { 75 | return _head; 76 | } 77 | 78 | void movePointers(ptrdiff_t stringDistance, ptrdiff_t variantDistance); 79 | 80 | private: 81 | VariantSlot *getSlot(size_t index) const; 82 | 83 | template 84 | VariantSlot *getSlot(TAdaptedString key) const; 85 | 86 | VariantSlot *getPreviousSlot(VariantSlot *) const; 87 | }; 88 | } // namespace ARDUINOJSON_NAMESPACE 89 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Deserialization/Filter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | class Filter { 12 | public: 13 | explicit Filter(VariantConstRef v) : _variant(v) {} 14 | 15 | bool allow() const { 16 | return _variant; 17 | } 18 | 19 | bool allowArray() const { 20 | return _variant == true || _variant.is(); 21 | } 22 | 23 | bool allowObject() const { 24 | return _variant == true || _variant.is(); 25 | } 26 | 27 | bool allowValue() const { 28 | return _variant == true; 29 | } 30 | 31 | template 32 | Filter operator[](const TKey& key) const { 33 | if (_variant == true) // "true" means "allow recursively" 34 | return *this; 35 | VariantConstRef member = _variant[key]; 36 | return Filter(member.isNull() ? _variant["*"] : member); 37 | } 38 | 39 | private: 40 | VariantConstRef _variant; 41 | }; 42 | 43 | struct AllowAllFilter { 44 | bool allow() const { 45 | return true; 46 | } 47 | 48 | bool allowArray() const { 49 | return true; 50 | } 51 | 52 | bool allowObject() const { 53 | return true; 54 | } 55 | 56 | bool allowValue() const { 57 | return true; 58 | } 59 | 60 | template 61 | AllowAllFilter operator[](const TKey&) const { 62 | return AllowAllFilter(); 63 | } 64 | }; 65 | 66 | } // namespace ARDUINOJSON_NAMESPACE 67 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Deserialization/NestingLimit.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | class NestingLimit { 13 | public: 14 | NestingLimit() : _value(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {} 15 | explicit NestingLimit(uint8_t n) : _value(n) {} 16 | 17 | NestingLimit decrement() const { 18 | ARDUINOJSON_ASSERT(_value > 0); 19 | return NestingLimit(static_cast(_value - 1)); 20 | } 21 | 22 | bool reached() const { 23 | return _value == 0; 24 | } 25 | 26 | private: 27 | uint8_t _value; 28 | }; 29 | } // namespace ARDUINOJSON_NAMESPACE 30 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Deserialization/Reader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // for size_t 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | // The default reader is a simple wrapper for Readers that are not copiable 14 | template 15 | struct Reader { 16 | public: 17 | Reader(TSource& source) : _source(&source) {} 18 | 19 | int read() { 20 | return _source->read(); // Error here? You passed an unsupported input type 21 | } 22 | 23 | size_t readBytes(char* buffer, size_t length) { 24 | return _source->readBytes(buffer, length); 25 | } 26 | 27 | private: 28 | TSource* _source; 29 | }; 30 | 31 | template 32 | struct BoundedReader { 33 | // no default implementation because we need to pass the size to the 34 | // constructor 35 | }; 36 | } // namespace ARDUINOJSON_NAMESPACE 37 | 38 | #include 39 | #include 40 | #include 41 | 42 | #if ARDUINOJSON_ENABLE_ARDUINO_STREAM 43 | # include 44 | #endif 45 | 46 | #if ARDUINOJSON_ENABLE_ARDUINO_STRING 47 | # include 48 | #endif 49 | 50 | #if ARDUINOJSON_ENABLE_PROGMEM 51 | # include 52 | #endif 53 | 54 | #if ARDUINOJSON_ENABLE_STD_STREAM 55 | # include 56 | #endif 57 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct Reader::value>::type> { 14 | public: 15 | explicit Reader(Stream& stream) : _stream(&stream) {} 16 | 17 | int read() { 18 | // don't use _stream.read() as it ignores the timeout 19 | char c; 20 | return _stream->readBytes(&c, 1) ? static_cast(c) : -1; 21 | } 22 | 23 | size_t readBytes(char* buffer, size_t length) { 24 | return _stream->readBytes(buffer, length); 25 | } 26 | 27 | private: 28 | Stream* _stream; 29 | }; 30 | 31 | } // namespace ARDUINOJSON_NAMESPACE 32 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | namespace ARDUINOJSON_NAMESPACE { 8 | 9 | template 10 | struct Reader::value>::type> 12 | : BoundedReader { 13 | explicit Reader(const ::String& s) 14 | : BoundedReader(s.c_str(), s.length()) {} 15 | }; 16 | 17 | } // namespace ARDUINOJSON_NAMESPACE 18 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Deserialization/Readers/FlashReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | namespace ARDUINOJSON_NAMESPACE { 8 | 9 | template <> 10 | struct Reader { 11 | const char* _ptr; 12 | 13 | public: 14 | explicit Reader(const __FlashStringHelper* ptr) 15 | : _ptr(reinterpret_cast(ptr)) {} 16 | 17 | int read() { 18 | return pgm_read_byte(_ptr++); 19 | } 20 | 21 | size_t readBytes(char* buffer, size_t length) { 22 | memcpy_P(buffer, _ptr, length); 23 | _ptr += length; 24 | return length; 25 | } 26 | }; 27 | 28 | template <> 29 | struct BoundedReader { 30 | const char* _ptr; 31 | const char* _end; 32 | 33 | public: 34 | explicit BoundedReader(const __FlashStringHelper* ptr, size_t size) 35 | : _ptr(reinterpret_cast(ptr)), _end(_ptr + size) {} 36 | 37 | int read() { 38 | if (_ptr < _end) 39 | return pgm_read_byte(_ptr++); 40 | else 41 | return -1; 42 | } 43 | 44 | size_t readBytes(char* buffer, size_t length) { 45 | size_t available = static_cast(_end - _ptr); 46 | if (available < length) 47 | length = available; 48 | memcpy_P(buffer, _ptr, length); 49 | _ptr += length; 50 | return length; 51 | } 52 | }; 53 | } // namespace ARDUINOJSON_NAMESPACE 54 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Deserialization/Readers/IteratorReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | namespace ARDUINOJSON_NAMESPACE { 8 | 9 | template 10 | class IteratorReader { 11 | TIterator _ptr, _end; 12 | 13 | public: 14 | explicit IteratorReader(TIterator begin, TIterator end) 15 | : _ptr(begin), _end(end) {} 16 | 17 | int read() { 18 | if (_ptr < _end) 19 | return static_cast(*_ptr++); 20 | else 21 | return -1; 22 | } 23 | 24 | size_t readBytes(char* buffer, size_t length) { 25 | size_t i = 0; 26 | while (i < length && _ptr < _end) buffer[i++] = *_ptr++; 27 | return i; 28 | } 29 | }; 30 | 31 | template 32 | struct void_ { 33 | typedef void type; 34 | }; 35 | 36 | template 37 | struct Reader::type> 38 | : IteratorReader { 39 | explicit Reader(const TSource& source) 40 | : IteratorReader(source.begin(), 41 | source.end()) {} 42 | }; 43 | } // namespace ARDUINOJSON_NAMESPACE 44 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Deserialization/Readers/RamReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct IsCharOrVoid { 13 | static const bool value = 14 | is_same::value || is_same::value || 15 | is_same::value || is_same::value; 16 | }; 17 | 18 | template 19 | struct IsCharOrVoid : IsCharOrVoid {}; 20 | 21 | template 22 | struct Reader::value>::type> { 24 | const char* _ptr; 25 | 26 | public: 27 | explicit Reader(const void* ptr) 28 | : _ptr(ptr ? reinterpret_cast(ptr) : "") {} 29 | 30 | int read() { 31 | return static_cast(*_ptr++); 32 | } 33 | 34 | size_t readBytes(char* buffer, size_t length) { 35 | for (size_t i = 0; i < length; i++) buffer[i] = *_ptr++; 36 | return length; 37 | } 38 | }; 39 | 40 | template 41 | struct BoundedReader::value>::type> 43 | : public IteratorReader { 44 | public: 45 | explicit BoundedReader(const void* ptr, size_t len) 46 | : IteratorReader(reinterpret_cast(ptr), 47 | reinterpret_cast(ptr) + len) {} 48 | }; 49 | 50 | } // namespace ARDUINOJSON_NAMESPACE 51 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct Reader::value>::type> { 14 | public: 15 | explicit Reader(std::istream& stream) : _stream(&stream) {} 16 | 17 | int read() { 18 | return _stream->get(); 19 | } 20 | 21 | size_t readBytes(char* buffer, size_t length) { 22 | _stream->read(buffer, static_cast(length)); 23 | return static_cast(_stream->gcount()); 24 | } 25 | 26 | private: 27 | std::istream* _stream; 28 | }; 29 | } // namespace ARDUINOJSON_NAMESPACE 30 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Deserialization/Readers/VariantReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | template 13 | struct Reader, void> : Reader { 14 | explicit Reader(const ElementProxy& x) 15 | : Reader(x.template as()) {} 16 | }; 17 | 18 | template 19 | struct Reader, void> : Reader { 20 | explicit Reader(const MemberProxy& x) 21 | : Reader(x.template as()) {} 22 | }; 23 | 24 | template <> 25 | struct Reader : Reader { 26 | explicit Reader(VariantRef x) : Reader(x.as()) {} 27 | }; 28 | 29 | template <> 30 | struct Reader : Reader { 31 | explicit Reader(VariantConstRef x) 32 | : Reader(x.as()) {} 33 | }; 34 | } // namespace ARDUINOJSON_NAMESPACE 35 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Document/DynamicJsonDocument.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // malloc, free 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | struct DefaultAllocator { 14 | void* allocate(size_t size) { 15 | return malloc(size); 16 | } 17 | 18 | void deallocate(void* ptr) { 19 | free(ptr); 20 | } 21 | 22 | void* reallocate(void* ptr, size_t new_size) { 23 | return realloc(ptr, new_size); 24 | } 25 | }; 26 | 27 | typedef BasicJsonDocument DynamicJsonDocument; 28 | 29 | } // namespace ARDUINOJSON_NAMESPACE 30 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Document/StaticJsonDocument.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | class StaticJsonDocument : public JsonDocument { 13 | static const size_t _capacity = 14 | AddPadding::value>::value; 15 | 16 | public: 17 | StaticJsonDocument() : JsonDocument(_buffer, _capacity) {} 18 | 19 | StaticJsonDocument(const StaticJsonDocument& src) 20 | : JsonDocument(_buffer, _capacity) { 21 | set(src); 22 | } 23 | 24 | template 25 | StaticJsonDocument(const T& src, 26 | typename enable_if::value>::type* = 0) 27 | : JsonDocument(_buffer, _capacity) { 28 | set(src); 29 | } 30 | 31 | // disambiguate 32 | StaticJsonDocument(VariantRef src) : JsonDocument(_buffer, _capacity) { 33 | set(src); 34 | } 35 | 36 | StaticJsonDocument operator=(const StaticJsonDocument& src) { 37 | set(src); 38 | return *this; 39 | } 40 | 41 | template 42 | StaticJsonDocument operator=(const T& src) { 43 | set(src); 44 | return *this; 45 | } 46 | 47 | void garbageCollect() { 48 | StaticJsonDocument tmp(*this); 49 | set(tmp); 50 | } 51 | 52 | private: 53 | char _buffer[_capacity]; 54 | }; 55 | 56 | } // namespace ARDUINOJSON_NAMESPACE 57 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Json/EscapeSequence.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | class EscapeSequence { 12 | public: 13 | // Optimized for code size on a 8-bit AVR 14 | static char escapeChar(char c) { 15 | const char *p = escapeTable(true); 16 | while (p[0] && p[1] != c) { 17 | p += 2; 18 | } 19 | return p[0]; 20 | } 21 | 22 | // Optimized for code size on a 8-bit AVR 23 | static char unescapeChar(char c) { 24 | const char *p = escapeTable(false); 25 | for (;;) { 26 | if (p[0] == '\0') 27 | return 0; 28 | if (p[0] == c) 29 | return p[1]; 30 | p += 2; 31 | } 32 | } 33 | 34 | private: 35 | static const char *escapeTable(bool excludeSolidus) { 36 | return &"//\"\"\\\\b\bf\fn\nr\rt\t"[excludeSolidus ? 2 : 0]; 37 | } 38 | }; 39 | } // namespace ARDUINOJSON_NAMESPACE 40 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Json/Latch.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | class Latch { 13 | public: 14 | Latch(TReader reader) : _reader(reader), _loaded(false) { 15 | #if ARDUINOJSON_DEBUG 16 | _ended = false; 17 | #endif 18 | } 19 | 20 | void clear() { 21 | _loaded = false; 22 | } 23 | 24 | int last() const { 25 | return _current; 26 | } 27 | 28 | FORCE_INLINE char current() { 29 | if (!_loaded) { 30 | load(); 31 | } 32 | return _current; 33 | } 34 | 35 | private: 36 | void load() { 37 | ARDUINOJSON_ASSERT(!_ended); 38 | int c = _reader.read(); 39 | #if ARDUINOJSON_DEBUG 40 | if (c <= 0) 41 | _ended = true; 42 | #endif 43 | _current = static_cast(c > 0 ? c : 0); 44 | _loaded = true; 45 | } 46 | 47 | TReader _reader; 48 | char _current; // NOLINT(clang-analyzer-optin.cplusplus.UninitializedObject) 49 | // Not initialized in constructor (+10 bytes on AVR) 50 | bool _loaded; 51 | #if ARDUINOJSON_DEBUG 52 | bool _ended; 53 | #endif 54 | }; 55 | 56 | } // namespace ARDUINOJSON_NAMESPACE 57 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Json/Utf16.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // uint16_t, uint32_t 10 | 11 | // The high surrogate may be uninitialized if the pair is invalid, 12 | // we choose to ignore the problem to reduce the size of the code 13 | // Garbage in => Garbage out 14 | #if defined(__GNUC__) 15 | # if __GNUC__ >= 7 16 | # pragma GCC diagnostic push 17 | # pragma GCC diagnostic ignored "-Wmaybe-uninitialized" 18 | # endif 19 | #endif 20 | 21 | namespace ARDUINOJSON_NAMESPACE { 22 | 23 | namespace Utf16 { 24 | inline bool isHighSurrogate(uint16_t codeunit) { 25 | return codeunit >= 0xD800 && codeunit < 0xDC00; 26 | } 27 | 28 | inline bool isLowSurrogate(uint16_t codeunit) { 29 | return codeunit >= 0xDC00 && codeunit < 0xE000; 30 | } 31 | 32 | class Codepoint { 33 | public: 34 | Codepoint() : _highSurrogate(0), _codepoint(0) {} 35 | 36 | bool append(uint16_t codeunit) { 37 | if (isHighSurrogate(codeunit)) { 38 | _highSurrogate = codeunit & 0x3FF; 39 | return false; 40 | } 41 | 42 | if (isLowSurrogate(codeunit)) { 43 | _codepoint = 44 | uint32_t(0x10000 + ((_highSurrogate << 10) | (codeunit & 0x3FF))); 45 | return true; 46 | } 47 | 48 | _codepoint = codeunit; 49 | return true; 50 | } 51 | 52 | uint32_t value() const { 53 | return _codepoint; 54 | } 55 | 56 | private: 57 | uint16_t _highSurrogate; 58 | uint32_t _codepoint; 59 | }; 60 | } // namespace Utf16 61 | } // namespace ARDUINOJSON_NAMESPACE 62 | 63 | #if defined(__GNUC__) 64 | # if __GNUC__ >= 8 65 | # pragma GCC diagnostic pop 66 | # endif 67 | #endif 68 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Json/Utf8.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | namespace Utf8 { 12 | template 13 | inline void encodeCodepoint(uint32_t codepoint32, TStringBuilder& str) { 14 | // this function was optimize for code size on AVR 15 | 16 | if (codepoint32 < 0x80) { 17 | str.append(char(codepoint32)); 18 | } else { 19 | // a buffer to store the string in reverse 20 | char buf[5]; 21 | char* p = buf; 22 | 23 | *(p++) = 0; 24 | *(p++) = char((codepoint32 | 0x80) & 0xBF); 25 | uint16_t codepoint16 = uint16_t(codepoint32 >> 6); 26 | if (codepoint16 < 0x20) { // 0x800 27 | *(p++) = char(codepoint16 | 0xC0); 28 | } else { 29 | *(p++) = char((codepoint16 | 0x80) & 0xBF); 30 | codepoint16 = uint16_t(codepoint16 >> 6); 31 | if (codepoint16 < 0x10) { // 0x10000 32 | *(p++) = char(codepoint16 | 0xE0); 33 | } else { 34 | *(p++) = char((codepoint16 | 0x80) & 0xBF); 35 | codepoint16 = uint16_t(codepoint16 >> 6); 36 | *(p++) = char(codepoint16 | 0xF0); 37 | } 38 | } 39 | 40 | while (*(--p)) { 41 | str.append(*p); 42 | } 43 | } 44 | } 45 | } // namespace Utf8 46 | } // namespace ARDUINOJSON_NAMESPACE 47 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Memory/Alignment.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // size_t 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | #if ARDUINOJSON_ENABLE_ALIGNMENT 14 | 15 | inline bool isAligned(size_t value) { 16 | const size_t mask = sizeof(void *) - 1; 17 | size_t addr = value; 18 | return (addr & mask) == 0; 19 | } 20 | 21 | inline size_t addPadding(size_t bytes) { 22 | const size_t mask = sizeof(void *) - 1; 23 | return (bytes + mask) & ~mask; 24 | } 25 | 26 | template 27 | struct AddPadding { 28 | static const size_t mask = sizeof(void *) - 1; 29 | static const size_t value = (bytes + mask) & ~mask; 30 | }; 31 | 32 | #else 33 | 34 | inline bool isAligned(size_t) { 35 | return true; 36 | } 37 | 38 | inline size_t addPadding(size_t bytes) { 39 | return bytes; 40 | } 41 | 42 | template 43 | struct AddPadding { 44 | static const size_t value = bytes; 45 | }; 46 | 47 | #endif 48 | 49 | template 50 | inline bool isAligned(T *ptr) { 51 | return isAligned(reinterpret_cast(ptr)); 52 | } 53 | 54 | template 55 | inline T *addPadding(T *p) { 56 | size_t address = addPadding(reinterpret_cast(p)); 57 | return reinterpret_cast(address); 58 | } 59 | 60 | } // namespace ARDUINOJSON_NAMESPACE 61 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Misc/SerializedValue.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A special type of data that can be used to insert pregenerated JSON portions. 12 | template 13 | class SerializedValue { 14 | public: 15 | explicit SerializedValue(T str) : _str(str) {} 16 | operator T() const { 17 | return _str; 18 | } 19 | 20 | const char* data() const { 21 | return _str.c_str(); 22 | } 23 | 24 | size_t size() const { 25 | // CAUTION: the old Arduino String doesn't have size() 26 | return _str.length(); 27 | } 28 | 29 | private: 30 | T _str; 31 | }; 32 | 33 | template 34 | class SerializedValue { 35 | public: 36 | explicit SerializedValue(TChar* p, size_t n) : _data(p), _size(n) {} 37 | operator TChar*() const { 38 | return _data; 39 | } 40 | 41 | TChar* data() const { 42 | return _data; 43 | } 44 | 45 | size_t size() const { 46 | return _size; 47 | } 48 | 49 | private: 50 | TChar* _data; 51 | size_t _size; 52 | }; 53 | 54 | template 55 | inline SerializedValue serialized(T str) { 56 | return SerializedValue(str); 57 | } 58 | 59 | template 60 | inline SerializedValue serialized(TChar* p) { 61 | return SerializedValue(p, adaptString(p).size()); 62 | } 63 | 64 | template 65 | inline SerializedValue serialized(TChar* p, size_t n) { 66 | return SerializedValue(p, n); 67 | } 68 | } // namespace ARDUINOJSON_NAMESPACE 69 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Misc/Visitable.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | struct Visitable { 12 | // template 13 | // void accept(Visitor&) const; 14 | }; 15 | 16 | template 17 | struct IsVisitable : is_base_of {}; 18 | 19 | template 20 | struct IsVisitable : IsVisitable {}; 21 | } // namespace ARDUINOJSON_NAMESPACE 22 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/MsgPack/endianess.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | #if ARDUINOJSON_LITTLE_ENDIAN 13 | inline void fixEndianess(uint8_t *p, integral_constant) { 14 | swap(p[0], p[7]); 15 | swap(p[1], p[6]); 16 | swap(p[2], p[5]); 17 | swap(p[3], p[4]); 18 | } 19 | 20 | inline void fixEndianess(uint8_t *p, integral_constant) { 21 | swap(p[0], p[3]); 22 | swap(p[1], p[2]); 23 | } 24 | 25 | inline void fixEndianess(uint8_t *p, integral_constant) { 26 | swap(p[0], p[1]); 27 | } 28 | 29 | inline void fixEndianess(uint8_t *, integral_constant) {} 30 | 31 | template 32 | inline void fixEndianess(T &value) { 33 | fixEndianess(reinterpret_cast(&value), 34 | integral_constant()); 35 | } 36 | #else 37 | template 38 | inline void fixEndianess(T &) {} 39 | #endif 40 | 41 | } // namespace ARDUINOJSON_NAMESPACE 42 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/MsgPack/ieee754.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | inline void doubleToFloat(const uint8_t d[8], uint8_t f[4]) { 12 | f[0] = uint8_t((d[0] & 0xC0) | (d[0] << 3 & 0x3f) | (d[1] >> 5)); 13 | f[1] = uint8_t((d[1] << 3) | (d[2] >> 5)); 14 | f[2] = uint8_t((d[2] << 3) | (d[3] >> 5)); 15 | f[3] = uint8_t((d[3] << 3) | (d[4] >> 5)); 16 | } 17 | 18 | } // namespace ARDUINOJSON_NAMESPACE 19 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Namespace.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | #ifndef ARDUINOJSON_NAMESPACE 12 | 13 | # define ARDUINOJSON_NAMESPACE \ 14 | ARDUINOJSON_CONCAT4( \ 15 | ARDUINOJSON_CONCAT4(ArduinoJson, ARDUINOJSON_VERSION_MAJOR, \ 16 | ARDUINOJSON_VERSION_MINOR, \ 17 | ARDUINOJSON_VERSION_REVISION), \ 18 | _, \ 19 | ARDUINOJSON_HEX_DIGIT( \ 20 | ARDUINOJSON_ENABLE_PROGMEM, ARDUINOJSON_USE_LONG_LONG, \ 21 | ARDUINOJSON_USE_DOUBLE, ARDUINOJSON_ENABLE_STRING_DEDUPLICATION), \ 22 | ARDUINOJSON_HEX_DIGIT( \ 23 | ARDUINOJSON_ENABLE_NAN, ARDUINOJSON_ENABLE_INFINITY, \ 24 | ARDUINOJSON_ENABLE_COMMENTS, ARDUINOJSON_DECODE_UNICODE)) 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Numbers/Float.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | #if ARDUINOJSON_USE_DOUBLE 13 | typedef double Float; 14 | #else 15 | typedef float Float; 16 | #endif 17 | } // namespace ARDUINOJSON_NAMESPACE 18 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Numbers/Integer.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | #include // int64_t 11 | 12 | namespace ARDUINOJSON_NAMESPACE { 13 | 14 | #if ARDUINOJSON_USE_LONG_LONG 15 | typedef int64_t Integer; 16 | typedef uint64_t UInt; 17 | #else 18 | typedef long Integer; 19 | typedef unsigned long UInt; 20 | #endif 21 | 22 | } // namespace ARDUINOJSON_NAMESPACE 23 | 24 | #if ARDUINOJSON_HAS_LONG_LONG && !ARDUINOJSON_USE_LONG_LONG 25 | # define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T) \ 26 | static_assert(sizeof(T) <= sizeof(ARDUINOJSON_NAMESPACE::Integer), \ 27 | "To use 64-bit integers with ArduinoJson, you must set " \ 28 | "ARDUINOJSON_USE_LONG_LONG to 1. See " \ 29 | "https://arduinojson.org/v6/api/config/use_long_long/"); 30 | #else 31 | # define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T) 32 | #endif 33 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Object/ObjectFunctions.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | typename TVisitor::result_type objectAccept(const CollectionData *obj, 13 | TVisitor &visitor) { 14 | if (obj) 15 | return visitor.visitObject(*obj); 16 | else 17 | return visitor.visitNull(); 18 | } 19 | 20 | inline bool objectEquals(const CollectionData *lhs, const CollectionData *rhs) { 21 | if (lhs == rhs) 22 | return true; 23 | if (!lhs || !rhs) 24 | return false; 25 | return lhs->equalsObject(*rhs); 26 | } 27 | 28 | template 29 | inline VariantData *objectGetMember(const CollectionData *obj, 30 | TAdaptedString key) { 31 | if (!obj) 32 | return 0; 33 | return obj->getMember(key); 34 | } 35 | 36 | template 37 | void objectRemove(CollectionData *obj, TAdaptedString key) { 38 | if (!obj) 39 | return; 40 | obj->removeMember(key); 41 | } 42 | 43 | template 44 | inline VariantData *objectGetOrAddMember(CollectionData *obj, 45 | TAdaptedString key, MemoryPool *pool) { 46 | if (!obj) 47 | return 0; 48 | 49 | return obj->getOrAddMember(key, pool); 50 | } 51 | } // namespace ARDUINOJSON_NAMESPACE 52 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Object/Pair.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | // A key value pair for CollectionData. 12 | class Pair { 13 | public: 14 | Pair(MemoryPool* pool, VariantSlot* slot) { 15 | if (slot) { 16 | _key = String(slot->key(), !slot->ownsKey()); 17 | _value = VariantRef(pool, slot->data()); 18 | } 19 | } 20 | 21 | String key() const { 22 | return _key; 23 | } 24 | 25 | VariantRef value() const { 26 | return _value; 27 | } 28 | 29 | private: 30 | String _key; 31 | VariantRef _value; 32 | }; 33 | 34 | class PairConst { 35 | public: 36 | PairConst(const VariantSlot* slot) { 37 | if (slot) { 38 | _key = String(slot->key(), !slot->ownsKey()); 39 | _value = VariantConstRef(slot->data()); 40 | } 41 | } 42 | 43 | String key() const { 44 | return _key; 45 | } 46 | 47 | VariantConstRef value() const { 48 | return _value; 49 | } 50 | 51 | private: 52 | String _key; 53 | VariantConstRef _value; 54 | }; 55 | } // namespace ARDUINOJSON_NAMESPACE 56 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/alias_cast.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include // for size_t 9 | 10 | #include 11 | #include "math.hpp" 12 | 13 | namespace ARDUINOJSON_NAMESPACE { 14 | 15 | template 16 | struct alias_cast_t { 17 | union { 18 | F raw; 19 | T data; 20 | }; 21 | }; 22 | 23 | template 24 | T alias_cast(F raw_data) { 25 | alias_cast_t ac; 26 | ac.raw = raw_data; 27 | return ac.data; 28 | } 29 | } // namespace ARDUINOJSON_NAMESPACE 30 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/assert.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #if ARDUINOJSON_DEBUG 10 | # include 11 | # define ARDUINOJSON_ASSERT(X) assert(X) 12 | #else 13 | # define ARDUINOJSON_ASSERT(X) ((void)0) 14 | #endif 15 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/attributes.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #ifdef _MSC_VER // Visual Studio 8 | 9 | # define FORCE_INLINE // __forceinline causes C4714 when returning std::string 10 | # define NO_INLINE __declspec(noinline) 11 | 12 | # ifndef ARDUINOJSON_DEPRECATED 13 | # define ARDUINOJSON_DEPRECATED(msg) __declspec(deprecated(msg)) 14 | # endif 15 | 16 | #elif defined(__GNUC__) // GCC or Clang 17 | 18 | # define FORCE_INLINE __attribute__((always_inline)) 19 | # define NO_INLINE __attribute__((noinline)) 20 | 21 | # ifndef ARDUINOJSON_DEPRECATED 22 | # if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5) 23 | # define ARDUINOJSON_DEPRECATED(msg) __attribute__((deprecated(msg))) 24 | # else 25 | # define ARDUINOJSON_DEPRECATED(msg) __attribute__((deprecated)) 26 | # endif 27 | # endif 28 | 29 | #else // Other compilers 30 | 31 | # define FORCE_INLINE 32 | # define NO_INLINE 33 | 34 | # ifndef ARDUINOJSON_DEPRECATED 35 | # define ARDUINOJSON_DEPRECATED(msg) 36 | # endif 37 | 38 | #endif 39 | 40 | #if __cplusplus >= 201103L 41 | # define NOEXCEPT noexcept 42 | #else 43 | # define NOEXCEPT throw() 44 | #endif 45 | 46 | #if defined(__has_attribute) 47 | # if __has_attribute(no_sanitize) 48 | # define ARDUINOJSON_NO_SANITIZE(check) __attribute__((no_sanitize(check))) 49 | # else 50 | # define ARDUINOJSON_NO_SANITIZE(check) 51 | # endif 52 | #else 53 | # define ARDUINOJSON_NO_SANITIZE(check) 54 | #endif 55 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/ctype.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | #ifndef isdigit 12 | inline bool isdigit(char c) { 13 | return '0' <= c && c <= '9'; 14 | } 15 | #endif 16 | 17 | inline bool issign(char c) { 18 | return '-' == c || c == '+'; 19 | } 20 | } // namespace ARDUINOJSON_NAMESPACE 21 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/integer.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include // int8_t, int16_t 8 | 9 | #include 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | template 14 | struct int_t; 15 | 16 | template <> 17 | struct int_t<8> { 18 | typedef int8_t type; 19 | }; 20 | 21 | template <> 22 | struct int_t<16> { 23 | typedef int16_t type; 24 | }; 25 | 26 | template <> 27 | struct int_t<32> { 28 | typedef int32_t type; 29 | }; 30 | } // namespace ARDUINOJSON_NAMESPACE 31 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/limits.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "type_traits.hpp" 8 | 9 | #ifdef _MSC_VER 10 | # pragma warning(push) 11 | # pragma warning(disable : 4310) 12 | #endif 13 | 14 | namespace ARDUINOJSON_NAMESPACE { 15 | 16 | // Differs from standard because we can't use the symbols "min" and "max" 17 | template 18 | struct numeric_limits; 19 | 20 | template 21 | struct numeric_limits::value>::type> { 22 | static T lowest() { 23 | return 0; 24 | } 25 | static T highest() { 26 | return T(-1); 27 | } 28 | }; 29 | 30 | template 31 | struct numeric_limits< 32 | T, typename enable_if::value && is_signed::value>::type> { 33 | static T lowest() { 34 | return T(T(1) << (sizeof(T) * 8 - 1)); 35 | } 36 | static T highest() { 37 | return T(~lowest()); 38 | } 39 | }; 40 | 41 | } // namespace ARDUINOJSON_NAMESPACE 42 | 43 | #ifdef _MSC_VER 44 | # pragma warning(pop) 45 | #endif 46 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/math.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // Some libraries #define isnan() and isinf() so we need to check before 12 | // using this name 13 | 14 | #ifndef isnan 15 | template 16 | bool isnan(T x) { 17 | return x != x; 18 | } 19 | #endif 20 | 21 | #ifndef isinf 22 | template 23 | bool isinf(T x) { 24 | return x != 0.0 && x * 2 == x; 25 | } 26 | #endif 27 | } // namespace ARDUINOJSON_NAMESPACE 28 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/mpl/max.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // for size_t 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | // A meta-function that returns the highest value 14 | template Y)> 15 | struct Max {}; 16 | 17 | template 18 | struct Max { 19 | static const size_t value = X; 20 | }; 21 | 22 | template 23 | struct Max { 24 | static const size_t value = Y; 25 | }; 26 | } // namespace ARDUINOJSON_NAMESPACE 27 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/pgmspace.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | // Wraps a const char* so that the our functions are picked only if the 13 | // originals are missing 14 | struct pgm_p { 15 | pgm_p(const char* p) : address(p) {} 16 | const char* address; 17 | }; 18 | } // namespace ARDUINOJSON_NAMESPACE 19 | 20 | #ifndef strlen_P 21 | inline size_t strlen_P(ARDUINOJSON_NAMESPACE::pgm_p s) { 22 | const char* p = s.address; 23 | ARDUINOJSON_ASSERT(p != NULL); 24 | while (pgm_read_byte(p)) p++; 25 | return size_t(p - s.address); 26 | } 27 | #endif 28 | 29 | #ifndef strncmp_P 30 | inline int strncmp_P(const char* a, ARDUINOJSON_NAMESPACE::pgm_p b, size_t n) { 31 | const char* s1 = a; 32 | const char* s2 = b.address; 33 | ARDUINOJSON_ASSERT(s1 != NULL); 34 | ARDUINOJSON_ASSERT(s2 != NULL); 35 | while (n-- > 0) { 36 | char c1 = *s1++; 37 | char c2 = static_cast(pgm_read_byte(s2++)); 38 | if (c1 < c2) 39 | return -1; 40 | if (c1 > c2) 41 | return 1; 42 | if (c1 == 0 /* and c2 as well */) 43 | return 0; 44 | } 45 | return 0; 46 | } 47 | #endif 48 | 49 | #ifndef strcmp_P 50 | inline int strcmp_P(const char* a, ARDUINOJSON_NAMESPACE::pgm_p b) { 51 | const char* s1 = a; 52 | const char* s2 = b.address; 53 | ARDUINOJSON_ASSERT(s1 != NULL); 54 | ARDUINOJSON_ASSERT(s2 != NULL); 55 | for (;;) { 56 | char c1 = *s1++; 57 | char c2 = static_cast(pgm_read_byte(s2++)); 58 | if (c1 < c2) 59 | return -1; 60 | if (c1 > c2) 61 | return 1; 62 | if (c1 == 0 /* and c2 as well */) 63 | return 0; 64 | } 65 | } 66 | #endif 67 | 68 | #ifndef memcpy_P 69 | inline void* memcpy_P(void* dst, ARDUINOJSON_NAMESPACE::pgm_p src, size_t n) { 70 | uint8_t* d = reinterpret_cast(dst); 71 | const char* s = src.address; 72 | ARDUINOJSON_ASSERT(d != NULL); 73 | ARDUINOJSON_ASSERT(s != NULL); 74 | while (n-- > 0) { 75 | *d++ = pgm_read_byte(s++); 76 | } 77 | return dst; 78 | } 79 | #endif 80 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/pgmspace_generic.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | template 13 | typename enable_if::value, T>::type pgm_read(const void* p) { 14 | return reinterpret_cast(pgm_read_ptr(p)); 15 | } 16 | 17 | template 18 | typename enable_if::value && 19 | sizeof(T) == sizeof(float), // on AVR sizeof(double) == 20 | // sizeof(float) 21 | T>::type 22 | pgm_read(const void* p) { 23 | return pgm_read_float(p); 24 | } 25 | 26 | template 27 | typename enable_if::value, T>::type pgm_read( 28 | const void* p) { 29 | return pgm_read_dword(p); 30 | } 31 | 32 | } // namespace ARDUINOJSON_NAMESPACE 33 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/preprocessor.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #define ARDUINOJSON_EXPAND6(a, b, c, d, e, f) a, b, c, d, e, f 8 | #define ARDUINOJSON_EXPAND9(a, b, c, d, e, f, g, h, i) a, b, c, d, e, f, g, h, i 9 | #define ARDUINOJSON_EXPAND18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, \ 10 | q, r) \ 11 | a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r 12 | 13 | #define ARDUINOJSON_CONCAT_(A, B) A##B 14 | #define ARDUINOJSON_CONCAT2(A, B) ARDUINOJSON_CONCAT_(A, B) 15 | #define ARDUINOJSON_CONCAT4(A, B, C, D) \ 16 | ARDUINOJSON_CONCAT2(ARDUINOJSON_CONCAT2(A, B), ARDUINOJSON_CONCAT2(C, D)) 17 | 18 | #define ARDUINOJSON_HEX_DIGIT_0000() 0 19 | #define ARDUINOJSON_HEX_DIGIT_0001() 1 20 | #define ARDUINOJSON_HEX_DIGIT_0010() 2 21 | #define ARDUINOJSON_HEX_DIGIT_0011() 3 22 | #define ARDUINOJSON_HEX_DIGIT_0100() 4 23 | #define ARDUINOJSON_HEX_DIGIT_0101() 5 24 | #define ARDUINOJSON_HEX_DIGIT_0110() 6 25 | #define ARDUINOJSON_HEX_DIGIT_0111() 7 26 | #define ARDUINOJSON_HEX_DIGIT_1000() 8 27 | #define ARDUINOJSON_HEX_DIGIT_1001() 9 28 | #define ARDUINOJSON_HEX_DIGIT_1010() A 29 | #define ARDUINOJSON_HEX_DIGIT_1011() B 30 | #define ARDUINOJSON_HEX_DIGIT_1100() C 31 | #define ARDUINOJSON_HEX_DIGIT_1101() D 32 | #define ARDUINOJSON_HEX_DIGIT_1110() E 33 | #define ARDUINOJSON_HEX_DIGIT_1111() F 34 | #define ARDUINOJSON_HEX_DIGIT_(A, B, C, D) ARDUINOJSON_HEX_DIGIT_##A##B##C##D() 35 | #define ARDUINOJSON_HEX_DIGIT(A, B, C, D) ARDUINOJSON_HEX_DIGIT_(A, B, C, D) 36 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/safe_strcmp.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // int8_t 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | inline int safe_strcmp(const char* a, const char* b) { 14 | if (a == b) 15 | return 0; 16 | if (!a) 17 | return -1; 18 | if (!b) 19 | return 1; 20 | return strcmp(a, b); 21 | } 22 | 23 | inline int safe_strncmp(const char* a, const char* b, size_t n) { 24 | if (a == b) 25 | return 0; 26 | if (!a) 27 | return -1; 28 | if (!b) 29 | return 1; 30 | return strncmp(a, b, n); 31 | } 32 | } // namespace ARDUINOJSON_NAMESPACE 33 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/static_array.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #if ARDUINOJSON_ENABLE_PROGMEM 10 | 11 | # include 12 | 13 | # ifndef ARDUINOJSON_DEFINE_STATIC_ARRAY 14 | # define ARDUINOJSON_DEFINE_STATIC_ARRAY(type, name, value) \ 15 | static type const name[] PROGMEM = value; 16 | # endif 17 | 18 | # ifndef ARDUINOJSON_READ_STATIC_ARRAY 19 | # define ARDUINOJSON_READ_STATIC_ARRAY(type, name, index) \ 20 | pgm_read(name + index) 21 | # endif 22 | 23 | #else // i.e. ARDUINOJSON_ENABLE_PROGMEM == 0 24 | 25 | # ifndef ARDUINOJSON_DEFINE_STATIC_ARRAY 26 | # define ARDUINOJSON_DEFINE_STATIC_ARRAY(type, name, value) \ 27 | static type const name[] = value; 28 | # endif 29 | 30 | # ifndef ARDUINOJSON_READ_STATIC_ARRAY 31 | # define ARDUINOJSON_READ_STATIC_ARRAY(type, name, index) name[index] 32 | # endif 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "type_traits/conditional.hpp" 8 | #include "type_traits/enable_if.hpp" 9 | #include "type_traits/integral_constant.hpp" 10 | #include "type_traits/is_array.hpp" 11 | #include "type_traits/is_base_of.hpp" 12 | #include "type_traits/is_class.hpp" 13 | #include "type_traits/is_const.hpp" 14 | #include "type_traits/is_convertible.hpp" 15 | #include "type_traits/is_enum.hpp" 16 | #include "type_traits/is_floating_point.hpp" 17 | #include "type_traits/is_integral.hpp" 18 | #include "type_traits/is_pointer.hpp" 19 | #include "type_traits/is_same.hpp" 20 | #include "type_traits/is_signed.hpp" 21 | #include "type_traits/is_unsigned.hpp" 22 | #include "type_traits/make_unsigned.hpp" 23 | #include "type_traits/make_void.hpp" 24 | #include "type_traits/remove_const.hpp" 25 | #include "type_traits/remove_reference.hpp" 26 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/conditional.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct conditional { 13 | typedef TrueType type; 14 | }; 15 | 16 | template 17 | struct conditional { 18 | typedef FalseType type; 19 | }; 20 | } // namespace ARDUINOJSON_NAMESPACE 21 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/declval.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | T declval(); 13 | 14 | } // namespace ARDUINOJSON_NAMESPACE 15 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/enable_if.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A meta-function that return the type T if Condition is true. 12 | template 13 | struct enable_if {}; 14 | 15 | template 16 | struct enable_if { 17 | typedef T type; 18 | }; 19 | } // namespace ARDUINOJSON_NAMESPACE 20 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/integral_constant.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct integral_constant { 13 | static const T value = v; 14 | }; 15 | 16 | typedef integral_constant true_type; 17 | typedef integral_constant false_type; 18 | 19 | } // namespace ARDUINOJSON_NAMESPACE 20 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_array.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // size_t 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | template 14 | struct is_array : false_type {}; 15 | 16 | template 17 | struct is_array : true_type {}; 18 | 19 | template 20 | struct is_array : true_type {}; 21 | } // namespace ARDUINOJSON_NAMESPACE 22 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_base_of.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A meta-function that returns true if Derived inherits from TBase is an 12 | // integral type. 13 | template 14 | class is_base_of { 15 | protected: // <- to avoid GCC's "all member functions in class are private" 16 | typedef char Yes[1]; 17 | typedef char No[2]; 18 | 19 | static Yes &probe(const TBase *); 20 | static No &probe(...); 21 | 22 | public: 23 | static const bool value = 24 | sizeof(probe(reinterpret_cast(0))) == sizeof(Yes); 25 | }; 26 | } // namespace ARDUINOJSON_NAMESPACE 27 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_class.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "declval.hpp" 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct is_class { 13 | protected: // <- to avoid GCC's "all member functions in class are private" 14 | typedef char Yes[1]; 15 | typedef char No[2]; 16 | 17 | template 18 | static Yes &probe(void (U::*)(void)); 19 | template 20 | static No &probe(...); 21 | 22 | public: 23 | static const bool value = sizeof(probe(0)) == sizeof(Yes); 24 | }; 25 | 26 | } // namespace ARDUINOJSON_NAMESPACE 27 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_const.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A meta-function that return the type T without the const modifier 12 | template 13 | struct is_const : false_type {}; 14 | 15 | template 16 | struct is_const : true_type {}; 17 | } // namespace ARDUINOJSON_NAMESPACE 18 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "declval.hpp" 8 | 9 | #ifdef _MSC_VER 10 | # pragma warning(push) 11 | // conversion from 'T' to 'To', possible loss of data 12 | # pragma warning(disable : 4244) 13 | #endif 14 | 15 | // clang-format off 16 | #ifdef __ICCARM__ 17 | // Suppress IAR Compiler Warning[Pa093]: implicit conversion from floating point to integer 18 | #pragma diag_suppress=Pa093 19 | #endif 20 | // clang-format on 21 | 22 | namespace ARDUINOJSON_NAMESPACE { 23 | 24 | template 25 | struct is_convertible { 26 | protected: // <- to avoid GCC's "all member functions in class are private" 27 | typedef char Yes[1]; 28 | typedef char No[2]; 29 | 30 | static Yes &probe(To); 31 | static No &probe(...); 32 | 33 | public: 34 | static const bool value = sizeof(probe(declval())) == sizeof(Yes); 35 | }; 36 | 37 | } // namespace ARDUINOJSON_NAMESPACE 38 | 39 | #ifdef _MSC_VER 40 | # pragma warning(pop) 41 | #endif 42 | 43 | // clang-format off 44 | #ifdef __ICCARM__ 45 | #pragma diag_default=Pa093 46 | #endif 47 | // clang-format on 48 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_enum.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "is_class.hpp" 8 | #include "is_convertible.hpp" 9 | #include "is_floating_point.hpp" 10 | #include "is_integral.hpp" 11 | #include "is_same.hpp" 12 | 13 | namespace ARDUINOJSON_NAMESPACE { 14 | 15 | template 16 | struct is_enum { 17 | static const bool value = is_convertible::value && 18 | !is_class::value && !is_integral::value && 19 | !is_floating_point::value; 20 | }; 21 | 22 | } // namespace ARDUINOJSON_NAMESPACE 23 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_floating_point.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | #include "is_same.hpp" 9 | #include "remove_cv.hpp" 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | template 14 | struct is_floating_point 15 | : integral_constant< 16 | bool, // 17 | is_same::type>::value || 18 | is_same::type>::value> {}; 19 | 20 | } // namespace ARDUINOJSON_NAMESPACE 21 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_integral.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include "integral_constant.hpp" 10 | #include "is_same.hpp" 11 | #include "remove_cv.hpp" 12 | 13 | namespace ARDUINOJSON_NAMESPACE { 14 | 15 | // clang-format off 16 | template 17 | struct is_integral : integral_constant::type, signed char>::value || 19 | is_same::type, unsigned char>::value || 20 | is_same::type, signed short>::value || 21 | is_same::type, unsigned short>::value || 22 | is_same::type, signed int>::value || 23 | is_same::type, unsigned int>::value || 24 | is_same::type, signed long>::value || 25 | is_same::type, unsigned long>::value || 26 | #if ARDUINOJSON_HAS_LONG_LONG 27 | is_same::type, signed long long>::value || 28 | is_same::type, unsigned long long>::value || 29 | #endif 30 | #if ARDUINOJSON_HAS_INT64 31 | is_same::type, signed __int64>::value || 32 | is_same::type, unsigned __int64>::value || 33 | #endif 34 | is_same::type, char>::value || 35 | is_same::type, bool>::value> {}; 36 | // clang-format on 37 | } // namespace ARDUINOJSON_NAMESPACE 38 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_pointer.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct is_pointer : false_type {}; 13 | 14 | template 15 | struct is_pointer : true_type {}; 16 | } // namespace ARDUINOJSON_NAMESPACE 17 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_same.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A meta-function that returns true if types T and U are the same. 12 | template 13 | struct is_same : false_type {}; 14 | 15 | template 16 | struct is_same : true_type {}; 17 | } // namespace ARDUINOJSON_NAMESPACE 18 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_signed.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | #include "is_same.hpp" 9 | #include "remove_cv.hpp" 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | // clang-format off 14 | template 15 | struct is_signed : integral_constant::type, char>::value || 17 | is_same::type, signed char>::value || 18 | is_same::type, signed short>::value || 19 | is_same::type, signed int>::value || 20 | is_same::type, signed long>::value || 21 | #if ARDUINOJSON_HAS_LONG_LONG 22 | is_same::type, signed long long>::value || 23 | #endif 24 | #if ARDUINOJSON_HAS_INT64 25 | is_same::type, signed __int64>::value || 26 | #endif 27 | is_same::type, float>::value || 28 | is_same::type, double>::value> {}; 29 | // clang-format on 30 | } // namespace ARDUINOJSON_NAMESPACE 31 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_unsigned.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | #include "is_same.hpp" 9 | #include "remove_cv.hpp" 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | // clang-format off 14 | template 15 | struct is_unsigned : integral_constant::type, unsigned char>::value || 17 | is_same::type, unsigned short>::value || 18 | is_same::type, unsigned int>::value || 19 | is_same::type, unsigned long>::value || 20 | #if ARDUINOJSON_HAS_INT64 21 | is_same::type, unsigned __int64>::value || 22 | #endif 23 | #if ARDUINOJSON_HAS_LONG_LONG 24 | is_same::type, unsigned long long>::value || 25 | #endif 26 | is_same::type, bool>::value> {}; 27 | // clang-format on 28 | } // namespace ARDUINOJSON_NAMESPACE 29 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/make_unsigned.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "type_identity.hpp" 8 | namespace ARDUINOJSON_NAMESPACE { 9 | 10 | template 11 | struct make_unsigned; 12 | 13 | template <> 14 | struct make_unsigned : type_identity {}; 15 | 16 | template <> 17 | struct make_unsigned : type_identity {}; 18 | template <> 19 | struct make_unsigned : type_identity {}; 20 | 21 | template <> 22 | struct make_unsigned : type_identity {}; 23 | template <> 24 | struct make_unsigned : type_identity {}; 25 | 26 | template <> 27 | struct make_unsigned : type_identity {}; 28 | template <> 29 | struct make_unsigned : type_identity {}; 30 | 31 | template <> 32 | struct make_unsigned : type_identity {}; 33 | template <> 34 | struct make_unsigned : type_identity {}; 35 | 36 | #if ARDUINOJSON_HAS_LONG_LONG 37 | template <> 38 | struct make_unsigned : type_identity {}; 39 | template <> 40 | struct make_unsigned : type_identity {}; 41 | #endif 42 | 43 | #if ARDUINOJSON_HAS_INT64 44 | template <> 45 | struct make_unsigned : type_identity {}; 46 | template <> 47 | struct make_unsigned : type_identity {}; 48 | #endif 49 | } // namespace ARDUINOJSON_NAMESPACE 50 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/make_void.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | namespace ARDUINOJSON_NAMESPACE { 8 | 9 | template 10 | struct make_void { 11 | typedef void type; 12 | }; 13 | 14 | } // namespace ARDUINOJSON_NAMESPACE 15 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/remove_const.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A meta-function that return the type T without the const modifier 12 | template 13 | struct remove_const { 14 | typedef T type; 15 | }; 16 | template 17 | struct remove_const { 18 | typedef T type; 19 | }; 20 | } // namespace ARDUINOJSON_NAMESPACE 21 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/remove_cv.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct remove_cv { 13 | typedef T type; 14 | }; 15 | template 16 | struct remove_cv { 17 | typedef T type; 18 | }; 19 | template 20 | struct remove_cv { 21 | typedef T type; 22 | }; 23 | template 24 | struct remove_cv { 25 | typedef T type; 26 | }; 27 | } // namespace ARDUINOJSON_NAMESPACE 28 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/remove_reference.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A meta-function that return the type T without the reference modifier. 12 | template 13 | struct remove_reference { 14 | typedef T type; 15 | }; 16 | template 17 | struct remove_reference { 18 | typedef T type; 19 | }; 20 | } // namespace ARDUINOJSON_NAMESPACE 21 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/type_identity.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct type_identity { 13 | typedef T type; 14 | }; 15 | } // namespace ARDUINOJSON_NAMESPACE 16 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Polyfills/utility.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "type_traits.hpp" 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | template 11 | inline void swap(T& a, T& b) { 12 | T t(a); 13 | a = b; 14 | b = t; 15 | } 16 | 17 | #if ARDUINOJSON_HAS_RVALUE_REFERENCES 18 | template 19 | typename remove_reference::type&& move(T&& t) { 20 | return static_cast::type&&>(t); 21 | } 22 | #else 23 | template 24 | T& move(T& t) { 25 | return t; 26 | } 27 | #endif 28 | } // namespace ARDUINOJSON_NAMESPACE 29 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Serialization/CountingDecorator.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | class CountingDecorator { 13 | public: 14 | explicit CountingDecorator(TWriter& writer) : _writer(writer), _count(0) {} 15 | 16 | void write(uint8_t c) { 17 | _count += _writer.write(c); 18 | } 19 | 20 | void write(const uint8_t* s, size_t n) { 21 | _count += _writer.write(s, n); 22 | } 23 | 24 | size_t count() const { 25 | return _count; 26 | } 27 | 28 | private: 29 | TWriter _writer; 30 | size_t _count; 31 | }; 32 | 33 | } // namespace ARDUINOJSON_NAMESPACE 34 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Serialization/Writer.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // The default writer is a simple wrapper for Writers that are not copiable 12 | template 13 | class Writer { 14 | public: 15 | explicit Writer(TDestination& dest) : _dest(&dest) {} 16 | 17 | size_t write(uint8_t c) { 18 | return _dest->write(c); 19 | } 20 | 21 | size_t write(const uint8_t* s, size_t n) { 22 | return _dest->write(s, n); 23 | } 24 | 25 | private: 26 | TDestination* _dest; 27 | }; 28 | 29 | } // namespace ARDUINOJSON_NAMESPACE 30 | 31 | #include 32 | 33 | #if ARDUINOJSON_ENABLE_STD_STRING 34 | # include 35 | #endif 36 | 37 | #if ARDUINOJSON_ENABLE_ARDUINO_STRING 38 | # include 39 | #endif 40 | 41 | #if ARDUINOJSON_ENABLE_STD_STREAM 42 | # include 43 | #endif 44 | 45 | #if ARDUINOJSON_ENABLE_ARDUINO_PRINT 46 | # include 47 | #endif 48 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template <> 12 | class Writer< ::String, void> { 13 | static const size_t bufferCapacity = ARDUINOJSON_STRING_BUFFER_SIZE; 14 | 15 | public: 16 | explicit Writer(::String &str) : _destination(&str) { 17 | _size = 0; 18 | } 19 | 20 | ~Writer() { 21 | flush(); 22 | } 23 | 24 | size_t write(uint8_t c) { 25 | if (_size + 1 >= bufferCapacity) 26 | if (flush() != 0) 27 | return 0; 28 | _buffer[_size++] = static_cast(c); 29 | return 1; 30 | } 31 | 32 | size_t write(const uint8_t *s, size_t n) { 33 | for (size_t i = 0; i < n; i++) { 34 | write(s[i]); 35 | } 36 | return n; 37 | } 38 | 39 | size_t flush() { 40 | ARDUINOJSON_ASSERT(_size < bufferCapacity); 41 | _buffer[_size] = 0; 42 | if (_destination->concat(_buffer)) 43 | _size = 0; 44 | return _size; 45 | } 46 | 47 | private: 48 | ::String *_destination; 49 | char _buffer[bufferCapacity]; 50 | size_t _size; 51 | }; 52 | 53 | } // namespace ARDUINOJSON_NAMESPACE 54 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Serialization/Writers/DummyWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | class DummyWriter { 12 | public: 13 | size_t write(uint8_t) { 14 | return 1; 15 | } 16 | 17 | size_t write(const uint8_t*, size_t n) { 18 | return n; 19 | } 20 | }; 21 | } // namespace ARDUINOJSON_NAMESPACE 22 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Serialization/Writers/PrintWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | namespace ARDUINOJSON_NAMESPACE { 8 | 9 | template 10 | class Writer< 11 | TDestination, 12 | typename enable_if::value>::type> { 13 | public: 14 | explicit Writer(::Print& print) : _print(&print) {} 15 | 16 | size_t write(uint8_t c) { 17 | return _print->write(c); 18 | } 19 | 20 | size_t write(const uint8_t* s, size_t n) { 21 | return _print->write(s, n); 22 | } 23 | 24 | private: 25 | ::Print* _print; 26 | }; 27 | 28 | } // namespace ARDUINOJSON_NAMESPACE 29 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Serialization/Writers/StaticStringWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | class StaticStringWriter { 12 | public: 13 | StaticStringWriter(char *buf, size_t size) : end(buf + size), p(buf) {} 14 | 15 | size_t write(uint8_t c) { 16 | if (p >= end) 17 | return 0; 18 | *p++ = static_cast(c); 19 | return 1; 20 | } 21 | 22 | size_t write(const uint8_t *s, size_t n) { 23 | char *begin = p; 24 | while (p < end && n > 0) { 25 | *p++ = static_cast(*s++); 26 | n--; 27 | } 28 | return size_t(p - begin); 29 | } 30 | 31 | private: 32 | char *end; 33 | char *p; 34 | }; 35 | } // namespace ARDUINOJSON_NAMESPACE 36 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | class Writer< 13 | TDestination, 14 | typename enable_if::value>::type> { 15 | public: 16 | explicit Writer(std::ostream& os) : _os(&os) {} 17 | 18 | size_t write(uint8_t c) { 19 | _os->put(static_cast(c)); 20 | return 1; 21 | } 22 | 23 | size_t write(const uint8_t* s, size_t n) { 24 | _os->write(reinterpret_cast(s), 25 | static_cast(n)); 26 | return n; 27 | } 28 | 29 | private: 30 | std::ostream* _os; 31 | }; 32 | } // namespace ARDUINOJSON_NAMESPACE 33 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Serialization/Writers/StdStringWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | #include 11 | 12 | namespace ARDUINOJSON_NAMESPACE { 13 | 14 | template 15 | struct is_std_string : false_type {}; 16 | 17 | template 18 | struct is_std_string > 19 | : true_type {}; 20 | 21 | template 22 | class Writer::value>::type> { 24 | public: 25 | Writer(TDestination &str) : _str(&str) {} 26 | 27 | size_t write(uint8_t c) { 28 | _str->operator+=(static_cast(c)); 29 | return 1; 30 | } 31 | 32 | size_t write(const uint8_t *s, size_t n) { 33 | _str->append(reinterpret_cast(s), n); 34 | return n; 35 | } 36 | 37 | private: 38 | TDestination *_str; 39 | }; 40 | } // namespace ARDUINOJSON_NAMESPACE 41 | -------------------------------------------------------------------------------- /.pio/libdeps/nodemcuv2/ArduinoJson/src/ArduinoJson/Serialization/measure.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - https://arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2021 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template