Skip to content

J
json
Commit 617b3cf4 by Francois Chabot
Options

templated input adapters

parent 973c52dd
Showing with 159 additions and 98 deletions
include/nlohmann/detail/input/binary_reader.hpp
......@@ -31,9 +31,10 @@ namespace detail
/*!
@brief deserialization of CBOR, MessagePack, and UBJSON values
*/
template<typename BasicJsonType, typename SAX = json_sax_dom_parser<BasicJsonType>>
template<typename BasicJsonType, typename SAX = json_sax_dom_parser<BasicJsonType>, typename InputAdapterType = input_adapter_protocol>
class binary_reader
{
using input_adapter_ptr_t = std::shared_ptr<InputAdapterType>;
using number_integer_t = typename BasicJsonType::number_integer_t;
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
using number_float_t = typename BasicJsonType::number_float_t;
......@@ -46,7 +47,7 @@ class binary_reader
@param[in] adapter input adapter to read from
*/
explicit binary_reader(input_adapter_t adapter) : ia(std::move(adapter))
explicit binary_reader(input_adapter_ptr_t adapter) : ia(std::move(adapter))
{
(void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
assert(ia);
......@@ -1965,7 +1966,7 @@ class binary_reader
private:
/// input adapter
input_adapter_t ia = nullptr;
input_adapter_ptr_t ia = nullptr;
/// the current character
int current = std::char_traits<char>::eof();
......
include/nlohmann/detail/input/input_adapters.hpp
......@@ -45,14 +45,11 @@ struct input_adapter_protocol
virtual ~input_adapter_protocol() = default;
};
/// a type to simplify interfaces
using input_adapter_t = std::shared_ptr<input_adapter_protocol>;
/*!
Input adapter for stdio file access. This adapter read only 1 byte and do not use any
buffer. This adapter is a very low level adapter.
*/
class file_input_adapter : public input_adapter_protocol
class file_input_adapter final : public input_adapter_protocol
{
public:
JSON_HEDLEY_NON_NULL(2)
......@@ -87,7 +84,7 @@ characters following those used in parsing the JSON input. Clears the
std::istream flags; any input errors (e.g., EOF) will be detected by the first
subsequent call for input from the std::istream.
*/
class input_stream_adapter : public input_adapter_protocol
class input_stream_adapter final : public input_adapter_protocol
{
public:
~input_stream_adapter() override
......@@ -128,7 +125,7 @@ class input_stream_adapter : public input_adapter_protocol
};
/// input adapter for buffer input
class input_buffer_adapter : public input_adapter_protocol
class input_buffer_adapter final : public input_adapter_protocol
{
public:
input_buffer_adapter(const char* b, const std::size_t l) noexcept
......@@ -285,7 +282,7 @@ struct wide_string_input_helper<WideStringType, 2>
};
template<typename WideStringType>
class wide_string_input_adapter : public input_adapter_protocol
class wide_string_input_adapter final : public input_adapter_protocol
{
public:
explicit wide_string_input_adapter(const WideStringType& w) noexcept
......@@ -331,60 +328,50 @@ class wide_string_input_adapter : public input_adapter_protocol
std::size_t utf8_bytes_filled = 0;
};
class input_adapter
inline std::shared_ptr<file_input_adapter> input_adapter(std::FILE* file)
{
public:
// native support
JSON_HEDLEY_NON_NULL(2)
input_adapter(std::FILE* file)
: ia(std::make_shared<file_input_adapter>(file)) {}
/// input adapter for input stream
input_adapter(std::istream& i)
: ia(std::make_shared<input_stream_adapter>(i)) {}
/// input adapter for input stream
input_adapter(std::istream&& i)
: ia(std::make_shared<input_stream_adapter>(i)) {}
return std::make_shared<file_input_adapter>(file);
}
input_adapter(const std::wstring& ws)
: ia(std::make_shared<wide_string_input_adapter<std::wstring>>(ws)) {}
input_adapter(const std::u16string& ws)
: ia(std::make_shared<wide_string_input_adapter<std::u16string>>(ws)) {}
inline std::shared_ptr<input_stream_adapter> input_adapter(std::istream& stream)
{
return std::make_shared<input_stream_adapter>(stream);
}
input_adapter(const std::u32string& ws)
: ia(std::make_shared<wide_string_input_adapter<std::u32string>>(ws)) {}
inline std::shared_ptr<input_stream_adapter> input_adapter(std::istream&& stream)
{
return std::make_shared<input_stream_adapter>(stream);
}
/// input adapter for buffer
template<typename CharT,
template<typename CharT,
typename std::enable_if<
std::is_pointer<CharT>::value and
std::is_integral<typename std::remove_pointer<CharT>::type>::value and
sizeof(typename std::remove_pointer<CharT>::type) == 1,
int>::type = 0>
input_adapter(CharT b, std::size_t l)
: ia(std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(b), l)) {}
// derived support
std::shared_ptr<input_buffer_adapter> input_adapter(CharT b, std::size_t l)
{
return std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(b), l);
}
/// input adapter for string literal
template<typename CharT,
template<typename CharT,
typename std::enable_if<
std::is_pointer<CharT>::value and
std::is_integral<typename std::remove_pointer<CharT>::type>::value and
sizeof(typename std::remove_pointer<CharT>::type) == 1,
int>::type = 0>
input_adapter(CharT b)
: input_adapter(reinterpret_cast<const char*>(b),
std::strlen(reinterpret_cast<const char*>(b))) {}
std::shared_ptr<input_buffer_adapter> input_adapter(CharT b)
{
return input_adapter(reinterpret_cast<const char*>(b),
std::strlen(reinterpret_cast<const char*>(b)));
}
/// input adapter for iterator range with contiguous storage
template<class IteratorType,
template<class IteratorType,
typename std::enable_if<
std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
int>::type = 0>
input_adapter(IteratorType first, IteratorType last)
{
std::shared_ptr<input_buffer_adapter> input_adapter(IteratorType first, IteratorType last)
{
#ifndef NDEBUG
// assertion to check that the iterator range is indeed contiguous,
// see https://stackoverflow.com/a/35008842/266378 for more discussion
......@@ -407,36 +394,98 @@ class input_adapter
if (JSON_HEDLEY_LIKELY(len > 0))
{
// there is at least one element: use the address of first
ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);
return std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);
}
else
{
// the address of first cannot be used: use nullptr
ia = std::make_shared<input_buffer_adapter>(nullptr, len);
}
return std::make_shared<input_buffer_adapter>(nullptr, len);
}
}
inline std::shared_ptr<wide_string_input_adapter<std::wstring>> input_adapter(const std::wstring& ws)
{
return std::make_shared<wide_string_input_adapter<std::wstring>>(ws);
}
inline std::shared_ptr<wide_string_input_adapter<std::u16string>> input_adapter(const std::u16string& ws)
{
return std::make_shared<wide_string_input_adapter<std::u16string>>(ws);
}
inline std::shared_ptr<wide_string_input_adapter<std::u32string>> input_adapter(const std::u32string& ws)
{
return std::make_shared<wide_string_input_adapter<std::u32string>>(ws);
}
template<class ContiguousContainer, typename
std::enable_if<not std::is_pointer<ContiguousContainer>::value and
std::is_base_of<std::random_access_iterator_tag, typename iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value,
int>::type = 0>
std::shared_ptr<input_buffer_adapter> input_adapter(const ContiguousContainer& c)
{
return input_adapter(std::begin(c), std::end(c));
}
template<class T, std::size_t N>
std::shared_ptr<input_buffer_adapter> input_adapter(T (&array)[N])
{
return input_adapter(std::begin(array), std::end(array));
}
// This class only handles inputs of input_buffer_adapter type.
// It's required so that expressions like {ptr, len} can be implicitely casted
// to the correct adapter.
class span_input_adapter
{
public:
template<typename CharT,
typename std::enable_if<
std::is_pointer<CharT>::value and
std::is_integral<typename std::remove_pointer<CharT>::type>::value and
sizeof(typename std::remove_pointer<CharT>::type) == 1,
int>::type = 0>
span_input_adapter(CharT b, std::size_t l)
: ia(std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(b), l)) {}
template<typename CharT,
typename std::enable_if<
std::is_pointer<CharT>::value and
std::is_integral<typename std::remove_pointer<CharT>::type>::value and
sizeof(typename std::remove_pointer<CharT>::type) == 1,
int>::type = 0>
span_input_adapter(CharT b)
: span_input_adapter(reinterpret_cast<const char*>(b),
std::strlen(reinterpret_cast<const char*>(b))) {}
template<class IteratorType,
typename std::enable_if<
std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
int>::type = 0>
span_input_adapter(IteratorType first, IteratorType last)
: ia(input_adapter(first, last)) {}
/// input adapter for array
template<class T, std::size_t N>
input_adapter(T (&array)[N])
: input_adapter(std::begin(array), std::end(array)) {}
span_input_adapter(T (&array)[N])
: span_input_adapter(std::begin(array), std::end(array)) {}
/// input adapter for contiguous container
template<class ContiguousContainer, typename
std::enable_if<not std::is_pointer<ContiguousContainer>::value and
std::is_base_of<std::random_access_iterator_tag, typename iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value,
int>::type = 0>
input_adapter(const ContiguousContainer& c)
: input_adapter(std::begin(c), std::end(c)) {}
span_input_adapter(const ContiguousContainer& c)
: span_input_adapter(std::begin(c), std::end(c)) {}
operator input_adapter_t()
std::shared_ptr<input_buffer_adapter> get()
{
return ia;
}
private:
/// the actual adapter
input_adapter_t ia = nullptr;
std::shared_ptr<input_buffer_adapter> ia = nullptr;
};
} // namespace detail
} // namespace nlohmann
include/nlohmann/detail/input/lexer.hpp
......@@ -22,19 +22,9 @@ namespace detail
// lexer //
///////////
/*!
@brief lexical analysis
This class organizes the lexical analysis during JSON deserialization.
*/
template<typename BasicJsonType>
class lexer
class lexer_base
{
using number_integer_t = typename BasicJsonType::number_integer_t;
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
using number_float_t = typename BasicJsonType::number_float_t;
using string_t = typename BasicJsonType::string_t;
public:
/// token types for the parser
enum class token_type
......@@ -75,9 +65,9 @@ class lexer
return "null literal";
case token_type::value_string:
return "string literal";
case lexer::token_type::value_unsigned:
case lexer::token_type::value_integer:
case lexer::token_type::value_float:
case token_type::value_unsigned:
case token_type::value_integer:
case token_type::value_float:
return "number literal";
case token_type::begin_array:
return "'['";
......@@ -103,15 +93,33 @@ class lexer
// LCOV_EXCL_STOP
}
}
};
/*!
@brief lexical analysis
This class organizes the lexical analysis during JSON deserialization.
*/
template<typename BasicJsonType, typename InputAdapterType = input_adapter_protocol>
class lexer : public lexer_base<BasicJsonType>
{
using input_adapter_ptr_t = std::shared_ptr<InputAdapterType>;
using number_integer_t = typename BasicJsonType::number_integer_t;
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
using number_float_t = typename BasicJsonType::number_float_t;
using string_t = typename BasicJsonType::string_t;
public:
using token_type = typename lexer_base<BasicJsonType>::token_type;
explicit lexer(detail::input_adapter_t&& adapter)
explicit lexer(input_adapter_ptr_t&& adapter)
: ia(std::move(adapter)), decimal_point_char(get_decimal_point()) {}
// delete because of pointer members
lexer(const lexer&) = delete;
lexer(lexer&&) = delete;
lexer(lexer&&) = default;
lexer& operator=(lexer&) = delete;
lexer& operator=(lexer&&) = delete;
lexer& operator=(lexer&&) = default;
~lexer() = default;
private:
......@@ -1480,7 +1488,7 @@ scan_number_done:
private:
/// input adapter
detail::input_adapter_t ia = nullptr;
input_adapter_ptr_t ia = nullptr;
/// the current character
std::char_traits<char>::int_type current = std::char_traits<char>::eof();
......
include/nlohmann/detail/input/parser.hpp
......@@ -24,24 +24,8 @@ namespace detail
// parser //
////////////
/*!
@brief syntax analysis
This class implements a recursive descent parser.
*/
template<typename BasicJsonType>
class parser
enum class parse_event_t : uint8_t
{
using number_integer_t = typename BasicJsonType::number_integer_t;
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
using number_float_t = typename BasicJsonType::number_float_t;
using string_t = typename BasicJsonType::string_t;
using lexer_t = lexer<BasicJsonType>;
using token_type = typename lexer_t::token_type;
public:
enum class parse_event_t : uint8_t
{
/// the parser read `{` and started to process a JSON object
object_start,
/// the parser read `}` and finished processing a JSON object
......@@ -54,14 +38,32 @@ class parser
key,
/// the parser finished reading a JSON value
value
};
};
using parser_callback_t =
template<typename BasicJsonType>
using parser_callback_t =
std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;
/*!
@brief syntax analysis
This class implements a recursive descent parser.
*/
template<typename BasicJsonType, typename InputAdapterType = input_adapter_protocol>
class parser
{
using input_adapter_ptr_t = std::shared_ptr<InputAdapterType>;
using number_integer_t = typename BasicJsonType::number_integer_t;
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
using number_float_t = typename BasicJsonType::number_float_t;
using string_t = typename BasicJsonType::string_t;
using lexer_t = lexer<BasicJsonType, InputAdapterType>;
using token_type = typename lexer_t::token_type;
public:
/// a parser reading from an input adapter
explicit parser(detail::input_adapter_t&& adapter,
const parser_callback_t cb = nullptr,
explicit parser(input_adapter_ptr_t&& adapter,
const parser_callback_t<BasicJsonType> cb = nullptr,
const bool allow_exceptions_ = true)
: callback(cb), m_lexer(std::move(adapter)), allow_exceptions(allow_exceptions_)
{
......@@ -486,7 +488,7 @@ class parser
private:
/// callback function
const parser_callback_t callback = nullptr;
const parser_callback_t<BasicJsonType> callback = nullptr;
/// the type of the last read token
token_type last_token = token_type::uninitialized;
/// the lexer
......
test/src/unit-class_lexer.cpp
......@@ -37,10 +37,11 @@ using nlohmann::json;
namespace
{
// shortcut to scan a string literal
json::lexer::token_type scan_string(const char* s);
json::lexer::token_type scan_string(const char* s)
{
return json::lexer(nlohmann::detail::input_adapter(s)).scan();
auto input_adapter = nlohmann::detail::input_adapter(s);
using input_adapter_type = typename decltype(input_adapter)::element_type;
return nlohmann::detail::lexer<json, input_adapter_type>(std::move(input_adapter)).scan();
}
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment