deserialize.hpp

00001 // ArduinoJson - arduinojson.org
00002 // Copyright Benoit Blanchon 2014-2021
00003 // MIT License
00004 
00005 #pragma once
00006 
00007 #include <ArduinoJson/Deserialization/DeserializationError.hpp>
00008 #include <ArduinoJson/Deserialization/Filter.hpp>
00009 #include <ArduinoJson/Deserialization/NestingLimit.hpp>
00010 #include <ArduinoJson/Deserialization/Reader.hpp>
00011 #include <ArduinoJson/StringStorage/StringStorage.hpp>
00012 
00013 namespace ARDUINOJSON_NAMESPACE {
00014 
00015 template <template <typename, typename> class TDeserializer, typename TReader,
00016           typename TWriter>
00017 TDeserializer<TReader, TWriter> makeDeserializer(MemoryPool &pool,
00018                                                  TReader reader,
00019                                                  TWriter writer) {
00020   return TDeserializer<TReader, TWriter>(pool, reader, writer);
00021 }
00022 
00023 // deserialize(JsonDocument&, const std::string&, NestingLimit, Filter);
00024 // deserialize(JsonDocument&, const String&, NestingLimit, Filter);
00025 // deserialize(JsonDocument&, char*, NestingLimit, Filter);
00026 // deserialize(JsonDocument&, const char*, NestingLimit, Filter);
00027 // deserialize(JsonDocument&, const __FlashStringHelper*, NestingLimit, Filter);
00028 template <template <typename, typename> class TDeserializer, typename TString,
00029           typename TFilter>
00030 typename enable_if<!is_array<TString>::value, DeserializationError>::type
00031 deserialize(JsonDocument &doc, const TString &input, NestingLimit nestingLimit,
00032             TFilter filter) {
00033   Reader<TString> reader(input);
00034   doc.clear();
00035   return makeDeserializer<TDeserializer>(
00036              doc.memoryPool(), reader,
00037              makeStringStorage(input, doc.memoryPool()))
00038       .parse(doc.data(), filter, nestingLimit);
00039 }
00040 //
00041 // deserialize(JsonDocument&, char*, size_t, NestingLimit, Filter);
00042 // deserialize(JsonDocument&, const char*, size_t, NestingLimit, Filter);
00043 // deserialize(JsonDocument&, const __FlashStringHelper*, size_t, NL, Filter);
00044 template <template <typename, typename> class TDeserializer, typename TChar,
00045           typename TFilter>
00046 DeserializationError deserialize(JsonDocument &doc, TChar *input,
00047                                  size_t inputSize, NestingLimit nestingLimit,
00048                                  TFilter filter) {
00049   BoundedReader<TChar *> reader(input, inputSize);
00050   doc.clear();
00051   return makeDeserializer<TDeserializer>(
00052              doc.memoryPool(), reader,
00053              makeStringStorage(input, doc.memoryPool()))
00054       .parse(doc.data(), filter, nestingLimit);
00055 }
00056 //
00057 // deserialize(JsonDocument&, std::istream&, NestingLimit, Filter);
00058 // deserialize(JsonDocument&, Stream&, NestingLimit, Filter);
00059 template <template <typename, typename> class TDeserializer, typename TStream,
00060           typename TFilter>
00061 DeserializationError deserialize(JsonDocument &doc, TStream &input,
00062                                  NestingLimit nestingLimit, TFilter filter) {
00063   Reader<TStream> reader(input);
00064   doc.clear();
00065   return makeDeserializer<TDeserializer>(
00066              doc.memoryPool(), reader,
00067              makeStringStorage(input, doc.memoryPool()))
00068       .parse(doc.data(), filter, nestingLimit);
00069 }
00070 
00071 }  // namespace ARDUINOJSON_NAMESPACE