diff options
Diffstat (limited to 'vendor/jsoncons-0.99.2/jsoncons_ext')
9 files changed, 0 insertions, 4469 deletions
diff --git a/vendor/jsoncons-0.99.2/jsoncons_ext/boost/type_extensions.hpp b/vendor/jsoncons-0.99.2/jsoncons_ext/boost/type_extensions.hpp deleted file mode 100644 index 59936cd7..00000000 --- a/vendor/jsoncons-0.99.2/jsoncons_ext/boost/type_extensions.hpp +++ /dev/null @@ -1,59 +0,0 @@ -// Copyright 2013 Daniel Parker -// Distributed under the Boost license, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -// See https://github.com/danielaparker/jsoncons for latest version - -#ifndef JSONCONS_EXT_TYPE_EXTENSIONS_HPP -#define JSONCONS_EXT_TYPE_EXTENSIONS_HPP - -#include "jsoncons/json.hpp" -#include "boost/date_time/gregorian/gregorian.hpp" - -#if defined(__GNUC__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wswitch" -#endif - -namespace jsoncons -{ - template <typename JsonT> - class json_type_traits<JsonT,boost::gregorian::date> - { - public: - static bool is(const JsonT& val) JSONCONS_NOEXCEPT - { - if (!val.is_string()) - { - return false; - } - std::string s = val.template as<std::string>(); - try - { - boost::gregorian::date_from_iso_string(s); - return true; - } - catch (...) - { - return false; - } - } - - static boost::gregorian::date as(const JsonT& val) - { - std::string s = val.template as<std::string>(); - return boost::gregorian::from_simple_string(s); - } - - static void assign(JsonT& lhs, boost::gregorian::date val) - { - lhs = to_iso_extended_string(val); - } - }; -} - -#if defined(__GNUC__) -#pragma GCC diagnostic pop -#endif - -#endif diff --git a/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_error_category.hpp b/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_error_category.hpp deleted file mode 100644 index 5056d380..00000000 --- a/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_error_category.hpp +++ /dev/null @@ -1,55 +0,0 @@ -/// Copyright 2013 Daniel Parker -// Distributed under the Boost license, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -// See https://github.com/danielaparker/jsoncons for latest version - -#ifndef JSONCONS_CSV_CSV_TEXT_ERROR_CATEGORY_HPP -#define JSONCONS_CSV_CSV_TEXT_ERROR_CATEGORY_HPP - -#include "jsoncons/jsoncons.hpp" -#include <system_error> - -namespace jsoncons { namespace csv { - -namespace csv_parser_errc -{ - const int unexpected_eof = 1; - const int expected_quote = 2; - const int invalid_csv_text = 3; - const int invalid_state = 4; -} - -class csv_error_category_impl - : public std::error_category -{ -public: - virtual const char* name() const JSONCONS_NOEXCEPT - { - return "csv"; - } - virtual std::string message(int ev) const - { - switch (ev) - { - case csv_parser_errc::unexpected_eof: - return "Unexpected end of file"; - case csv_parser_errc::expected_quote: - return "Expected quote character"; - case csv_parser_errc::invalid_csv_text: - return "Invalid CSV text"; - default: - return "Unknown JSON parser error"; - } - } -}; - -inline -const std::error_category& csv_error_category() -{ - static csv_error_category_impl instance; - return instance; -} - -}} -#endif diff --git a/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_parameters.hpp b/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_parameters.hpp deleted file mode 100644 index 099a154f..00000000 --- a/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_parameters.hpp +++ /dev/null @@ -1,341 +0,0 @@ -// Copyright 2013 Daniel Parker -// Distributed under the Boost license, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -// See https://github.com/danielaparker/jsoncons for latest version - -#ifndef JSONCONS_CSV_CSV_PARAMETERS_HPP -#define JSONCONS_CSV_CSV_PARAMETERS_HPP - -#include <string> -#include <sstream> -#include <vector> -#include <istream> -#include <ostream> -#include <cstdlib> -#include <limits> -#include <cwchar> - -namespace jsoncons { namespace csv { - -enum class quote_styles -{ - all,minimal,none,nonnumeric -}; - -template <typename CharT> -class basic_csv_parameters -{ -public: - static const size_t default_indent = 4; - -// Constructors - - basic_csv_parameters() - : - assume_header_(false), - ignore_empty_values_(false), - trim_leading_(false), - trim_trailing_(false), - trim_leading_inside_quotes_(false), - trim_trailing_inside_quotes_(false), - unquoted_empty_value_is_null_(false), - field_delimiter_(','), - quote_char_('\"'), - quote_escape_char_('\"'), - comment_starter_('\0'), - quote_style_(quote_styles::minimal), - max_lines_(std::numeric_limits<unsigned long>::max JSONCONS_NO_MACRO_EXP()), - header_lines_(0) - { - line_delimiter_.push_back('\n'); - } - -// Properties - - size_t header_lines() const - { - return (assume_header_ && header_lines_ <= 1) ? 1 : header_lines_; - } - - basic_csv_parameters<CharT>& header_lines(size_t value) - { - header_lines_ = value; - return *this; - } - - bool assume_header() const - { - return assume_header_; - } - - basic_csv_parameters<CharT>& assume_header(bool value) - { - assume_header_ = value; - return *this; - } - - bool ignore_empty_values() const - { - return ignore_empty_values_; - } - - basic_csv_parameters<CharT>& ignore_empty_values(bool value) - { - ignore_empty_values_ = value; - return *this; - } - - bool trim_leading() const - { - return trim_leading_; - } - - basic_csv_parameters<CharT>& trim_leading(bool value) - { - trim_leading_ = value; - return *this; - } - - bool trim_trailing() const - { - return trim_trailing_; - } - - basic_csv_parameters<CharT>& trim_trailing(bool value) - { - trim_trailing_ = value; - return *this; - } - - bool trim_leading_inside_quotes() const - { - return trim_leading_inside_quotes_; - } - - basic_csv_parameters<CharT>& trim_leading_inside_quotes(bool value) - { - trim_leading_inside_quotes_ = value; - return *this; - } - - bool trim_trailing_inside_quotes() const - { - return trim_trailing_inside_quotes_; - } - - basic_csv_parameters<CharT>& trim_trailing_inside_quotes(bool value) - { - trim_trailing_inside_quotes_ = value; - return *this; - } - - bool trim() const - { - return trim_leading_ && trim_trailing_; - } - - basic_csv_parameters<CharT>& trim(bool value) - { - trim_leading_ = value; - trim_trailing_ = value; - return *this; - } - - bool trim_inside_quotes() const - { - return trim_leading_inside_quotes_ && trim_trailing_inside_quotes_; - } - - basic_csv_parameters<CharT>& trim_inside_quotes(bool value) - { - trim_leading_inside_quotes_ = value; - trim_trailing_inside_quotes_ = value; - return *this; - } - - bool unquoted_empty_value_is_null() const - { - return unquoted_empty_value_is_null_; - } - - basic_csv_parameters<CharT>& unquoted_empty_value_is_null(bool value) - { - unquoted_empty_value_is_null_ = value; - return *this; - } - - std::vector<std::basic_string<CharT>> column_names() const - { - return column_names_; - } - - basic_csv_parameters<CharT>& column_names(const std::vector<std::basic_string<CharT>>& value) - { - column_names_ = value; - return *this; - } - - std::vector<std::basic_string<CharT>> column_types() const - { - return column_types_; - } - - basic_csv_parameters<CharT>& column_types(const std::vector<std::basic_string<CharT>>& value) - { - column_types_ = value; - return *this; - } - - std::vector<std::basic_string<CharT>> column_defaults() const - { - return column_defaults_; - } - - basic_csv_parameters<CharT>& column_defaults(const std::vector<std::basic_string<CharT>>& value) - { - column_defaults_ = value; - return *this; - } - - CharT field_delimiter() const - { - return field_delimiter_; - } - - basic_csv_parameters<CharT>& field_delimiter(CharT value) - { - field_delimiter_ = value; - return *this; - } - - std::basic_string<CharT> line_delimiter() const - { - return line_delimiter_; - } - - basic_csv_parameters<CharT>& line_delimiter(std::basic_string<CharT> value) - { - line_delimiter_ = value; - return *this; - } - - CharT quote_char() const - { - return quote_char_; - } - - basic_csv_parameters<CharT>& quote_char(CharT value) - { - quote_char_ = value; - return *this; - } - - CharT quote_escape_char() const - { - return quote_escape_char_; - } - - basic_csv_parameters<CharT>& quote_escape_char(CharT value) - { - quote_escape_char_ = value; - return *this; - } - - CharT comment_starter() const - { - return comment_starter_; - } - - basic_csv_parameters<CharT>& comment_starter(CharT value) - { - comment_starter_ = value; - return *this; - } - - quote_styles quote_style() const - { - return quote_style_; - } - - basic_csv_parameters<CharT>& assume_header(quote_styles value) - { - quote_style_ = value; - return *this; - } - - unsigned long max_lines() const - { - return max_lines_; - } - - basic_csv_parameters<CharT>& max_lines(unsigned long value) - { - max_lines_ = value; - return *this; - } - -#if !defined(JSONCONS_NO_DEPRECATED) - - std::basic_string<CharT> header() const - { - return header_; - } - - basic_csv_parameters<CharT>& header(const std::basic_string<CharT>& value) - { - header_ = value; - return *this; - } - - std::basic_string<CharT> data_types() const - { - return data_types_; - } - - basic_csv_parameters<CharT>& data_types(const std::basic_string<CharT>& value) - { - data_types_ = value; - return *this; - } - - std::basic_string<CharT> default_values() const - { - return default_values_; - } - - basic_csv_parameters<CharT>& default_values(const std::basic_string<CharT>& value) - { - default_values_ = value; - return *this; - } -#endif -private: - bool assume_header_; - bool ignore_empty_values_; - bool trim_leading_; - bool trim_trailing_; - bool trim_leading_inside_quotes_; - bool trim_trailing_inside_quotes_; - bool unquoted_empty_value_is_null_; - CharT field_delimiter_; - CharT quote_char_; - CharT quote_escape_char_; - CharT comment_starter_; - quote_styles quote_style_; - unsigned long max_lines_; - size_t header_lines_; - std::basic_string<CharT> line_delimiter_; - std::basic_string<CharT> header_; - std::basic_string<CharT> data_types_; - std::basic_string<CharT> default_values_; - std::vector<std::basic_string<CharT>> column_names_; - std::vector<std::basic_string<CharT>> column_types_; - std::vector<std::basic_string<CharT>> column_defaults_; -}; - -typedef basic_csv_parameters<char> csv_parameters; -typedef basic_csv_parameters<wchar_t> wcsv_parameters; - -}} -#endif diff --git a/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_parser.hpp b/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_parser.hpp deleted file mode 100644 index 14323666..00000000 --- a/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_parser.hpp +++ /dev/null @@ -1,903 +0,0 @@ -// Copyright 2015 Daniel Parker -// Distributed under the Boost license, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -// See https://github.com/danielaparker/jsoncons for latest version - -#ifndef JSONCONS_CSV_CSV_PARSER_HPP -#define JSONCONS_CSV_CSV_PARSER_HPP - -#include <memory> -#include <string> -#include <sstream> -#include <vector> -#include <istream> -#include <cstdlib> -#include <stdexcept> -#include <system_error> -#include <cctype> -#include "jsoncons/jsoncons.hpp" -#include "jsoncons/json_input_handler.hpp" -#include "jsoncons/parse_error_handler.hpp" -#include "jsoncons/json_parser.hpp" -#include "jsoncons/json_filter.hpp" -#include "jsoncons_ext/csv/csv_error_category.hpp" -#include "jsoncons_ext/csv/csv_parameters.hpp" - -namespace jsoncons { namespace csv { - -template <typename CharT> -struct json_csv_parser_traits -{ -}; - -template <> -struct json_csv_parser_traits<char> -{ - static const std::string string_literal() {return "string";}; - - static const std::string integer_literal() {return "integer";}; - - static const std::string float_literal() {return "float";}; - - static const std::string boolean_literal() {return "boolean";}; -}; - -template <> -struct json_csv_parser_traits<wchar_t> // assume utf16 -{ - static const std::wstring string_literal() {return L"string";}; - - static const std::wstring integer_literal() {return L"integer";}; - - static const std::wstring float_literal() {return L"float";}; - - static const std::wstring boolean_literal() {return L"boolean";}; -}; - -enum class csv_modes { - done, - header, - array, - object -}; - -enum class csv_states -{ - start, - comment, - expect_value, - between_fields, - quoted_string, - unquoted_string, - escaped_value, - minus, - zero, - integer, - fraction, - exp1, - exp2, - exp3, - done -}; - -enum class data_types -{ - string_t,integer_t,float_t,boolean_t -}; - -template<typename CharT> -class basic_csv_parser : private basic_parsing_context<CharT> -{ - static const int default_depth = 3; - - csv_states state_; - int top_; - std::vector<csv_modes> stack_; - basic_json_input_handler<CharT> *handler_; - basic_parse_error_handler<CharT> *err_handler_; - bool is_negative_; - uint32_t cp_; - size_t index_; - unsigned long column_; - unsigned long line_; - int curr_char_; - int prev_char_; - std::basic_string<CharT> string_buffer_; - csv_states saved_state_; - int depth_; - basic_csv_parameters<CharT> parameters_; - std::vector<std::basic_string<CharT>> column_names_; - std::vector<data_types> column_types_; - std::vector<std::basic_string<CharT>> column_defaults_; - size_t column_index_; - basic_begin_end_json_filter<CharT> filter_; - basic_json_parser<CharT> parser_; - -public: - basic_csv_parser(basic_json_input_handler<CharT>& handler) - : top_(-1), - stack_(default_depth), - handler_(std::addressof(handler)), - err_handler_(std::addressof(basic_default_parse_error_handler<CharT>::instance())), - is_negative_(false), - cp_(0), - index_(0), - filter_(handler), - parser_(filter_) - { - depth_ = default_depth; - state_ = csv_states::start; - top_ = -1; - line_ = 1; - column_ = 0; - column_index_ = 0; - } - - basic_csv_parser(basic_json_input_handler<CharT>& handler, - basic_csv_parameters<CharT> params) - : top_(-1), - stack_(default_depth), - handler_(std::addressof(handler)), - err_handler_(std::addressof(basic_default_parse_error_handler<CharT>::instance())), - is_negative_(false), - cp_(0), - index_(0), - parameters_(params), - filter_(handler), - parser_(filter_) - { - depth_ = default_depth; - state_ = csv_states::start; - top_ = -1; - line_ = 1; - column_ = 0; - column_index_ = 0; - } - - basic_csv_parser(basic_json_input_handler<CharT>& handler, - basic_parse_error_handler<CharT>& err_handler) - : top_(-1), - stack_(default_depth), - handler_(std::addressof(handler)), - err_handler_(std::addressof(err_handler)), - is_negative_(false), - cp_(0), - index_(0), - filter_(handler), - parser_(filter_) - { - depth_ = default_depth; - state_ = csv_states::start; - top_ = -1; - line_ = 1; - column_ = 0; - column_index_ = 0; - } - - basic_csv_parser(basic_json_input_handler<CharT>& handler, - basic_parse_error_handler<CharT>& err_handler, - basic_csv_parameters<CharT> params) - : top_(-1), - stack_(default_depth), - handler_(std::addressof(handler)), - err_handler_(std::addressof(err_handler)), - is_negative_(false), - cp_(0), - index_(0), - parameters_(params), - filter_(handler), - parser_(filter_) - { - depth_ = default_depth; - state_ = csv_states::start; - top_ = -1; - line_ = 1; - column_ = 0; - column_index_ = 0; - } - - ~basic_csv_parser() - { - } - - const basic_parsing_context<CharT>& parsing_context() const - { - return *this; - } - - bool done() const - { - return state_ == csv_states::done; - } - - const std::vector<std::basic_string<CharT>>& column_labels() const - { - return column_names_; - } - - void after_field() - { - ++column_index_; - } - - void before_record() - { - if (column_index_ == 0) - { - switch (stack_[top_]) - { - case csv_modes::array: - handler_->begin_array(*this); - break; - case csv_modes::object: - handler_->begin_object(*this); - break; - default: - break; - } - } - } - - void after_record() - { - switch (stack_[top_]) - { - case csv_modes::array: - handler_->end_array(*this); - break; - case csv_modes::object: - handler_->end_object(*this); - break; - case csv_modes::header: - if (line_ >= parameters_.header_lines()) - { - if (column_names_.size() > 0) - { - flip(csv_modes::header, csv_modes::object); - } - else - { - flip(csv_modes::header, csv_modes::array); - } - } - break; - default: - break; - } - column_index_ = 0; - } - - void begin_parse() - { - push(csv_modes::done); - handler_->begin_json(); - - if (parameters_.column_names().size() > 0) - { - column_names_ = parameters_.column_names(); - } -#if !defined(JSONCONS_NO_DEPRECATED) - else if (parameters_.header().length() > 0) - { - basic_empty_json_input_handler<CharT> ih; - basic_csv_parameters<CharT> params; - params.field_delimiter(parameters_.field_delimiter()); - params.quote_char(parameters_.quote_char()); - params.quote_escape_char(parameters_.quote_escape_char()); - params.assume_header(true); - basic_csv_parser<CharT> p(ih,params); - p.begin_parse(); - p.parse(parameters_.header().data(),0,parameters_.header().length()); - p.end_parse(); - column_names_ = p.column_labels(); - } -#endif - if (parameters_.column_types().size() > 0) - { - column_types_.resize(parameters_.column_types().size()); - for (size_t i = 0; i < parameters_.column_types().size(); ++i) - { - if (parameters_.column_types()[i] == json_csv_parser_traits<CharT>::string_literal()) - { - column_types_[i] = data_types::string_t; - } - else if (parameters_.column_types()[i] == json_csv_parser_traits<CharT>::integer_literal()) - { - column_types_[i] = data_types::integer_t; - } - else if (parameters_.column_types()[i] == json_csv_parser_traits<CharT>::float_literal()) - { - column_types_[i] = data_types::float_t; - } - else if (parameters_.column_types()[i] == json_csv_parser_traits<CharT>::boolean_literal()) - { - column_types_[i] = data_types::boolean_t; - } - } - } -#if !defined(JSONCONS_NO_DEPRECATED) - else if (parameters_.data_types().length() > 0) - { - basic_empty_json_input_handler<CharT> ih; - basic_csv_parameters<CharT> params; - params.field_delimiter(parameters_.field_delimiter()); - params.assume_header(true); - basic_csv_parser<CharT> p(ih,params); - p.begin_parse(); - p.parse(parameters_.data_types().data(),0,parameters_.data_types().length()); - p.end_parse(); - column_types_.resize(p.column_labels().size()); - for (size_t i = 0; i < p.column_labels().size(); ++i) - { - if (p.column_labels()[i] == json_csv_parser_traits<CharT>::string_literal()) - { - column_types_[i] = data_types::string_t; - } - else if (p.column_labels()[i] == json_csv_parser_traits<CharT>::integer_literal()) - { - column_types_[i] = data_types::integer_t; - } - else if (p.column_labels()[i] == json_csv_parser_traits<CharT>::float_literal()) - { - column_types_[i] = data_types::float_t; - } - else if (p.column_labels()[i] == json_csv_parser_traits<CharT>::boolean_literal()) - { - column_types_[i] = data_types::boolean_t; - } - } - } -#endif - if (parameters_.column_defaults().size() > 0) - { - column_defaults_ = parameters_.column_defaults(); - } -#if !defined(JSONCONS_NO_DEPRECATED) - else if (parameters_.default_values().length() > 0) - { - basic_empty_json_input_handler<CharT> ih; - basic_csv_parameters<CharT> params; - params.field_delimiter(parameters_.field_delimiter()); - params.assume_header(true); - basic_csv_parser<CharT> p(ih,params); - p.begin_parse(); - p.parse(parameters_.default_values().data(),0,parameters_.default_values().length()); - p.end_parse(); - column_defaults_.resize(p.column_labels().size()); - for (size_t i = 0; i < p.column_labels().size(); ++i) - { - column_defaults_[i] = p.column_labels()[i]; - } - } -#endif - if (parameters_.header_lines() > 0) - { - push(csv_modes::header); - } - else - { - push(csv_modes::array); - } - handler_->begin_array(*this); - state_ = csv_states::expect_value; - column_index_ = 0; - prev_char_ = 0; - curr_char_ = 0; - column_ = 1; - } - - void parse(const CharT* p, size_t start, size_t length) - { - index_ = start; - for (; index_ < length && state_ != csv_states::done; ++index_) - { - curr_char_ = p[index_]; -all_csv_states: - switch (state_) - { - case csv_states::comment: - if (curr_char_ == '\n') - { - state_ = csv_states::expect_value; - } - else if (prev_char_ == '\r') - { - state_ = csv_states::expect_value; - goto all_csv_states; - } - break; - case csv_states::expect_value: - if (column_ == 1 && curr_char_ == parameters_.comment_starter()) - { - state_ = csv_states::comment; - } - else - { - state_ = csv_states::unquoted_string; - goto all_csv_states; - } - break; - case csv_states::between_fields: - if (curr_char_ == '\r' || (prev_char_ != '\r' && curr_char_ == '\n')) - { - after_record(); - state_ = csv_states::expect_value; - } - else if (curr_char_ == parameters_.field_delimiter()) - { - state_ = csv_states::expect_value; - } - break; - case csv_states::escaped_value: - { - if (curr_char_ == parameters_.quote_char()) - { - string_buffer_.push_back(curr_char_); - state_ = csv_states::quoted_string; - } - else if (parameters_.quote_escape_char() == parameters_.quote_char()) - { - before_record(); - end_quoted_string_value(); - after_field(); - state_ = csv_states::between_fields; - goto all_csv_states; - } - } - break; - case csv_states::quoted_string: - { - if (curr_char_ == parameters_.quote_escape_char()) - { - state_ = csv_states::escaped_value; - } - else if (curr_char_ == parameters_.quote_char()) - { - before_record(); - end_quoted_string_value(); - after_field(); - state_ = csv_states::between_fields; - } - else - { - string_buffer_.push_back(curr_char_); - } - } - break; - case csv_states::unquoted_string: - { - if (curr_char_ == '\r' || (prev_char_ != '\r' && curr_char_ == '\n')) - { - before_record(); - end_unquoted_string_value(); - after_field(); - after_record(); - state_ = csv_states::expect_value; - } - else if (curr_char_ == '\n') - { - if (prev_char_ != '\r') - { - before_record(); - end_unquoted_string_value(); - after_field(); - after_record(); - state_ = csv_states::expect_value; - } - } - else if (curr_char_ == parameters_.field_delimiter()) - { - before_record(); - end_unquoted_string_value(); - after_field(); - state_ = csv_states::expect_value; - } - else if (curr_char_ == parameters_.quote_char()) - { - string_buffer_.clear(); - state_ = csv_states::quoted_string; - } - else - { - string_buffer_.push_back(curr_char_); - } - } - break; - default: - err_handler_->error(std::error_code(csv_parser_errc::invalid_state, csv_error_category()), *this); - break; - } - if (line_ > parameters_.max_lines()) - { - state_ = csv_states::done; - } - switch (curr_char_) - { - case '\r': - ++line_; - column_ = 1; - break; - case '\n': - if (prev_char_ != '\r') - { - ++line_; - } - column_ = 1; - break; - default: - ++column_; - break; - } - prev_char_ = curr_char_; - } - } - - void end_parse() - { - switch (state_) - { - case csv_states::unquoted_string: - before_record(); - end_unquoted_string_value(); - after_field(); - break; - case csv_states::escaped_value: - if (parameters_.quote_escape_char() == parameters_.quote_char()) - { - before_record(); - end_quoted_string_value(); - after_field(); - } - break; - default: - break; - } - if (column_index_ > 0) - { - after_record(); - } - switch (stack_[top_]) - { - case csv_modes::array: - if (!pop(csv_modes::array)) - { - err_handler_->error(std::error_code(csv_parser_errc::unexpected_eof, csv_error_category()), *this); - } - break; - case csv_modes::object: - if (!pop(csv_modes::object)) - { - err_handler_->error(std::error_code(csv_parser_errc::unexpected_eof, csv_error_category()), *this); - } - break; - case csv_modes::header: - if (!pop(csv_modes::header)) - { - err_handler_->error(std::error_code(csv_parser_errc::unexpected_eof, csv_error_category()), *this); - } - break; - default: - break; - } - handler_->end_array(*this); - if (!pop(csv_modes::done)) - { - err_handler_->error(std::error_code(csv_parser_errc::unexpected_eof, csv_error_category()), *this); - } - handler_->end_json(); - } - - csv_states state() const - { - return state_; - } - - size_t index() const - { - return index_; - } -private: - - void trim_string_buffer(bool trim_leading, bool trim_trailing) - { - size_t start = 0; - size_t length = string_buffer_.length(); - if (trim_leading) - { - bool done = false; - while (!done && start < string_buffer_.length()) - { - if ((string_buffer_[start] < 256) && std::isspace(string_buffer_[start])) - { - ++start; - } - else - { - done = true; - } - } - } - if (trim_trailing) - { - bool done = false; - while (!done && length > 0) - { - if ((string_buffer_[length-1] < 256) && std::isspace(string_buffer_[length-1])) - { - --length; - } - else - { - done = true; - } - } - } - if (start != 0 || length != string_buffer_.size()) - { - string_buffer_ = string_buffer_.substr(start,length-start); - } - } - - void end_unquoted_string_value() - { - if (parameters_.trim_leading() | parameters_.trim_trailing()) - { - trim_string_buffer(parameters_.trim_leading(),parameters_.trim_trailing()); - } - switch (stack_[top_]) - { - case csv_modes::header: - if (parameters_.assume_header() && line_ == 1) - { - column_names_.push_back(string_buffer_); - } - break; - case csv_modes::object: - if (!(parameters_.ignore_empty_values() && string_buffer_.size() == 0)) - { - if (column_index_ < column_names_.size()) - { - handler_->name(column_names_[column_index_].data(), column_names_[column_index_].length(), *this); - if (parameters_.unquoted_empty_value_is_null() && string_buffer_.length() == 0) - { - handler_->value(jsoncons::null_type(),*this); - } - else - { - end_value(); - } - } - } - break; - case csv_modes::array: - if (parameters_.unquoted_empty_value_is_null() && string_buffer_.length() == 0) - { - handler_->value(jsoncons::null_type(),*this); - } - else - { - end_value(); - } - break; - default: - err_handler_->error(std::error_code(csv_parser_errc::invalid_csv_text, csv_error_category()), *this); - break; - } - state_ = csv_states::expect_value; - string_buffer_.clear(); - } - - void end_quoted_string_value() - { - if (parameters_.trim_leading_inside_quotes() | parameters_.trim_trailing_inside_quotes()) - { - trim_string_buffer(parameters_.trim_leading_inside_quotes(),parameters_.trim_trailing_inside_quotes()); - } - switch (stack_[top_]) - { - case csv_modes::header: - if (parameters_.assume_header() && line_ == 1) - { - column_names_.push_back(string_buffer_); - } - break; - case csv_modes::object: - if (!(parameters_.ignore_empty_values() && string_buffer_.size() == 0)) - { - if (column_index_ < column_names_.size()) - { - handler_->name(column_names_[column_index_].data(), column_names_[column_index_].length(), *this); - end_value(); - } - } - break; - case csv_modes::array: - end_value(); - break; - default: - err_handler_->error(std::error_code(csv_parser_errc::invalid_csv_text, csv_error_category()), *this); - break; - } - state_ = csv_states::expect_value; - string_buffer_.clear(); - } - - void end_value() - { - if (column_index_ < column_types_.size()) - { - switch (column_types_[column_index_]) - { - case data_types::integer_t: - { - std::istringstream iss(string_buffer_); - long long val; - iss >> val; - if (!iss.fail()) - { - handler_->value(val, *this); - } - else - { - if (column_index_ < column_defaults_.size() && column_defaults_[column_index_].length() > 0) - { - parser_.begin_parse(); - parser_.parse(column_defaults_[column_index_].data(),0,column_defaults_[column_index_].length()); - parser_.end_parse(); - } - else - { - handler_->value(null_type(), *this); - } - } - } - break; - case data_types::float_t: - { - std::istringstream iss(string_buffer_); - double val; - iss >> val; - if (!iss.fail()) - { - handler_->value(val, 0, *this); - } - else - { - if (column_index_ < column_defaults_.size() && column_defaults_[column_index_].length() > 0) - { - parser_.begin_parse(); - parser_.parse(column_defaults_[column_index_].data(),0,column_defaults_[column_index_].length()); - parser_.end_parse(); - } - else - { - handler_->value(null_type(), *this); - } - } - } - break; - case data_types::boolean_t: - { - if (string_buffer_.length() == 1 && string_buffer_[0] == '0') - { - handler_->value(false, *this); - } - else if (string_buffer_.length() == 1 && string_buffer_[0] == '1') - { - handler_->value(true, *this); - } - else if (string_buffer_.length() == 5 && ((string_buffer_[0] == 'f' || string_buffer_[0] == 'F') && (string_buffer_[1] == 'a' || string_buffer_[1] == 'A') && (string_buffer_[2] == 'l' || string_buffer_[2] == 'L') && (string_buffer_[3] == 's' || string_buffer_[3] == 'S') && (string_buffer_[4] == 'e' || string_buffer_[4] == 'E'))) - { - handler_->value(false, *this); - } - else if (string_buffer_.length() == 4 && ((string_buffer_[0] == 't' || string_buffer_[0] == 'T') && (string_buffer_[1] == 'r' || string_buffer_[1] == 'R') && (string_buffer_[2] == 'u' || string_buffer_[2] == 'U') && (string_buffer_[3] == 'e' || string_buffer_[3] == 'E'))) - { - handler_->value(true, *this); - } - else - { - if (column_index_ < column_defaults_.size() && column_defaults_[column_index_].length() > 0) - { - parser_.begin_parse(); - parser_.parse(column_defaults_[column_index_].data(),0,column_defaults_[column_index_].length()); - parser_.end_parse(); - } - else - { - handler_->value(null_type(), *this); - } - } - } - break; - default: - if (string_buffer_.length() > 0) - { - handler_->value(string_buffer_.data(), string_buffer_.length(), *this); - } - else - { - if (column_index_ < column_defaults_.size() && column_defaults_[column_index_].length() > 0) - { - parser_.begin_parse(); - parser_.parse(column_defaults_[column_index_].data(),0,column_defaults_[column_index_].length()); - parser_.end_parse(); - } - else - { - handler_->value("", *this); - } - } - break; - } - } - else - { - handler_->value(string_buffer_.data(), string_buffer_.length(), *this); - } - } - - size_t do_line_number() const override - { - return line_; - } - - size_t do_column_number() const override - { - return column_; - } - - CharT do_current_char() const override - { - return (CharT)prev_char_; - } - - void push(csv_modes mode) - { - ++top_; - if (top_ >= depth_) - { - depth_ *= 2; - stack_.resize(depth_); - } - stack_[top_] = mode; - } - - int peek() - { - return stack_[top_]; - } - - bool peek(csv_modes mode) - { - return stack_[top_] == mode; - } - - bool flip(csv_modes mode1, csv_modes mode2) - { - if (top_ < 0 || stack_[top_] != mode1) - { - return false; - } - stack_[top_] = mode2; - return true; - } - - bool pop(csv_modes mode) - { - if (top_ < 0 || stack_[top_] != mode) - { - return false; - } - --top_; - return true; - } -}; - -typedef basic_csv_parser<char> csv_parser; -typedef basic_csv_parser<wchar_t> wcsv_parser; - -}} - -#endif - diff --git a/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_reader.hpp b/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_reader.hpp deleted file mode 100644 index 38213e25..00000000 --- a/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_reader.hpp +++ /dev/null @@ -1,175 +0,0 @@ -// Copyright 2013 Daniel Parker -// Distributed under the Boost license, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -// See https://github.com/danielaparker/jsoncons for latest version - -#ifndef JSONCONS_CSV_CSV_READER_HPP -#define JSONCONS_CSV_CSV_READER_HPP - -#include <string> -#include <sstream> -#include <vector> -#include <istream> -#include <cstdlib> -#include <stdexcept> -#include "jsoncons/jsoncons.hpp" -#include "jsoncons/json_input_handler.hpp" -#include "jsoncons/parse_error_handler.hpp" -#include "jsoncons_ext/csv/csv_error_category.hpp" -#include "jsoncons_ext/csv/csv_parser.hpp" -#include "jsoncons/json.hpp" - -namespace jsoncons { namespace csv { - -template<typename CharT> -class basic_csv_reader -{ - struct stack_item - { - stack_item() - : array_begun_(false) - { - } - - bool array_begun_; - }; -public: - // Structural characters - static const size_t default_max_buffer_length = 16384; - //! Parse an input stream of CSV text into a json object - /*! - \param is The input stream to read from - */ - - basic_csv_reader(std::basic_istream<CharT>& is, - basic_json_input_handler<CharT>& handler) - - : parser_(handler), - is_(std::addressof(is)), - buffer_(default_max_buffer_length), - buffer_capacity_(default_max_buffer_length), - buffer_position_(0), - buffer_length_(0), - eof_(false), - index_(0) - { - } - - basic_csv_reader(std::basic_istream<CharT>& is, - basic_json_input_handler<CharT>& handler, - basic_csv_parameters<CharT> params) - - : parser_(handler,params), - is_(std::addressof(is)), - buffer_(default_max_buffer_length), - buffer_capacity_(default_max_buffer_length), - buffer_position_(0), - buffer_length_(0), - eof_(false), - index_(0) - { - } - - basic_csv_reader(std::basic_istream<CharT>& is, - basic_json_input_handler<CharT>& handler, - basic_parse_error_handler<CharT>& err_handler) - : - parser_(handler,err_handler), - is_(std::addressof(is)), - buffer_(), - buffer_capacity_(default_max_buffer_length), - buffer_position_(0), - buffer_length_(0), - eof_(false), - index_(0) - - - { - } - - basic_csv_reader(std::basic_istream<CharT>& is, - basic_json_input_handler<CharT>& handler, - basic_parse_error_handler<CharT>& err_handler, - basic_csv_parameters<CharT> params) - : - parser_(handler,err_handler,params), - is_(std::addressof(is)), - buffer_(), - buffer_capacity_(default_max_buffer_length), - buffer_position_(0), - buffer_length_(0), - eof_(false), - index_(0) - { - } - - ~basic_csv_reader() - { - } - - void read() - { - parser_.begin_parse(); - while (!eof_ && !parser_.done()) - { - if (!(index_ < buffer_length_)) - { - if (!is_->eof()) - { - is_->read(buffer_.data(), buffer_capacity_); - buffer_length_ = static_cast<size_t>(is_->gcount()); - if (buffer_length_ == 0) - { - eof_ = true; - } - index_ = 0; - } - else - { - eof_ = true; - } - } - if (!eof_) - { - parser_.parse(buffer_.data(),index_,buffer_length_); - index_ = parser_.index(); - } - } - parser_.end_parse(); - } - - bool eof() const - { - return eof_; - } - - size_t buffer_capacity() const - { - return buffer_capacity_; - } - - void buffer_capacity(size_t buffer_capacity) - { - buffer_capacity_ = buffer_capacity; - } - -private: - basic_csv_reader(const basic_csv_reader&) = delete; - basic_csv_reader& operator = (const basic_csv_reader&) = delete; - - basic_csv_parser<CharT> parser_; - std::basic_istream<CharT>* is_; - std::vector<CharT> buffer_; - size_t buffer_capacity_; - size_t buffer_position_; - size_t buffer_length_; - bool eof_; - size_t index_; -}; - -typedef basic_csv_reader<char> csv_reader; - -}} - -#endif diff --git a/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_serializer.hpp b/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_serializer.hpp deleted file mode 100644 index f331b629..00000000 --- a/vendor/jsoncons-0.99.2/jsoncons_ext/csv/csv_serializer.hpp +++ /dev/null @@ -1,445 +0,0 @@ -// Copyright 2013 Daniel Parker -// Distributed under the Boost license, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -// See https://github.com/danielaparker/jsoncons for latest version - -#ifndef JSONCONS_CSV_CSV_SERIALIZER_HPP -#define JSONCONS_CSV_CSV_SERIALIZER_HPP - -#include <string> -#include <sstream> -#include <vector> -#include <ostream> -#include <cstdlib> -#include <map> -#include "jsoncons/jsoncons.hpp" -#include "jsoncons/output_format.hpp" -#include "jsoncons/json_output_handler.hpp" -#include <limits> // std::numeric_limits - -namespace jsoncons { namespace csv { - -template <typename CharT> -struct csv_char_traits -{ -}; - -template <> -struct csv_char_traits<char> -{ - static const std::string all_literal() {return "all";}; - - static const std::string minimal_literal() {return "minimal";}; - - static const std::string none_literal() {return "none";}; - - static const std::string nonnumeric_literal() {return "nonumeric";}; -}; - -template <> -struct csv_char_traits<wchar_t> -{ - static const std::wstring all_literal() {return L"all";}; - - static const std::wstring minimal_literal() {return L"minimal";}; - - static const std::wstring none_literal() {return L"none";}; - - static const std::wstring nonnumeric_literal() {return L"nonumeric";}; -}; - -template <typename CharT> -void escape_string(const CharT* s, - size_t length, - CharT quote_char, CharT quote_escape_char, - buffered_ostream<CharT>& os) -{ - const CharT* begin = s; - const CharT* end = s + length; - for (const CharT* it = begin; it != end; ++it) - { - CharT c = *it; - if (c == quote_char) - { - os.put(quote_escape_char); - os.put(quote_char); - } - else - { - os.put(c); - } - } -} - -template<typename CharT> -class basic_csv_serializer : public basic_json_output_handler<CharT> -{ - struct stack_item - { - stack_item(bool is_object) - : is_object_(is_object), count_(0), skip_(false) - { - } - bool is_object() const - { - return is_object_; - } - - bool is_object_; - size_t count_; - bool skip_; - }; - buffered_ostream<CharT> os_; - basic_csv_parameters<CharT> parameters_; - basic_output_format<CharT> format_; - std::vector<stack_item> stack_; - std::streamsize original_precision_; - std::ios_base::fmtflags original_format_flags_; - std::basic_ostringstream<CharT> header_oss_; - buffered_ostream<CharT> header_os_; - std::map<std::basic_string<CharT>,size_t> header_; - float_printer<CharT> fp_; -public: - basic_csv_serializer(std::basic_ostream<CharT>& os) - : - os_(os), - format_(), - stack_(), - original_precision_(), - original_format_flags_(), - header_os_(header_oss_), - header_(), - fp_(format_.precision()) - { - } - - basic_csv_serializer(std::basic_ostream<CharT>& os, - basic_csv_parameters<CharT> params) - : - os_(os), - parameters_(params), - format_(), - stack_(), - original_precision_(), - original_format_flags_(), - header_os_(header_oss_), - header_(), - fp_(format_.precision()) - { - } - - ~basic_csv_serializer() - { - } - -private: - - void do_begin_json() override - { - } - - void do_end_json() override - { - } - - void do_begin_object() override - { - stack_.push_back(stack_item(true)); - } - - void do_end_object() override - { - if (stack_.size() == 2) - { - os_.write(parameters_.line_delimiter()); - if (stack_[0].count_ == 0) - { - os_.write(header_oss_.str()); - os_.write(parameters_.line_delimiter()); - } - } - stack_.pop_back(); - - end_value(); - } - - void do_begin_array() override - { - stack_.push_back(stack_item(false)); - } - - void do_end_array() override - { - if (stack_.size() == 2) - { - os_.write(parameters_.line_delimiter()); - } - stack_.pop_back(); - - end_value(); - } - - void do_name(const CharT* name, size_t length) override - { - if (stack_.size() == 2) - { - if (stack_[0].count_ == 0) - { - if (stack_.back().count_ > 0) - { - os_.put(parameters_.field_delimiter()); - } - bool quote = false; - if (parameters_.quote_style() == quote_styles::all || parameters_.quote_style() == quote_styles::nonnumeric || - (parameters_.quote_style() == quote_styles::minimal && std::char_traits<CharT>::find(name,length,parameters_.field_delimiter()) != nullptr)) - { - quote = true; - os_.put(parameters_.quote_char()); - } - jsoncons::csv::escape_string<CharT>(name, length, parameters_.quote_char(), parameters_.quote_escape_char(), os_); - if (quote) - { - os_.put(parameters_.quote_char()); - } - header_[name] = stack_.back().count_; - } - else - { - typename std::map<std::basic_string<CharT>,size_t>::iterator it = header_.find(std::basic_string<CharT>(name,length)); - if (it == header_.end()) - { - stack_.back().skip_ = true; - //std::cout << " Not found "; - } - else - { - stack_.back().skip_ = false; - while (stack_.back().count_ < it->second) - { - os_.put(parameters_.field_delimiter()); - ++stack_.back().count_; - } - // std::cout << " (" << it->value() << " " << stack_.back().count_ << ") "; - } - } - } - } - - void do_null_value() override - { - if (stack_.size() == 2 && !stack_.back().skip_) - { - if (stack_.back().is_object() && stack_[0].count_ == 0) - { - do_null_value(header_os_); - } - else - { - do_null_value(os_); - } - } - } - - void do_string_value(const CharT* val, size_t length) override - { - if (stack_.size() == 2 && !stack_.back().skip_) - { - if (stack_.back().is_object() && stack_[0].count_ == 0) - { - value(val,length,header_os_); - } - else - { - value(val,length,os_); - } - } - } - - void do_double_value(double val, uint8_t precision) override - { - if (stack_.size() == 2 && !stack_.back().skip_) - { - if (stack_.back().is_object() && stack_[0].count_ == 0) - { - value(val,header_os_); - } - else - { - value(val,os_); - } - } - } - - void do_integer_value(int64_t val) override - { - if (stack_.size() == 2 && !stack_.back().skip_) - { - if (stack_.back().is_object() && stack_[0].count_ == 0) - { - value(val,header_os_); - } - else - { - value(val,os_); - } - } - } - - void do_uinteger_value(uint64_t val) override - { - if (stack_.size() == 2 && !stack_.back().skip_) - { - if (stack_.back().is_object() && stack_[0].count_ == 0) - { - value(val,header_os_); - } - else - { - value(val,os_); - } - } - } - - void do_bool_value(bool val) override - { - if (stack_.size() == 2 && !stack_.back().skip_) - { - if (stack_.back().is_object() && stack_[0].count_ == 0) - { - value(val,header_os_); - } - else - { - value(val,os_); - } - } - } - - void value(const CharT* val, size_t length, buffered_ostream<CharT>& os) - { - begin_value(os); - - bool quote = false; - if (parameters_.quote_style() == quote_styles::all || parameters_.quote_style() == quote_styles::nonnumeric || - (parameters_.quote_style() == quote_styles::minimal && std::char_traits<CharT>::find(val, length, parameters_.field_delimiter()) != nullptr)) - { - quote = true; - os.put(parameters_.quote_char()); - } - jsoncons::csv::escape_string<CharT>(val, length, parameters_.quote_char(), parameters_.quote_escape_char(), os); - if (quote) - { - os.put(parameters_.quote_char()); - } - - end_value(); - } - - void value(double val, buffered_ostream<CharT>& os) - { - begin_value(os); - - if (is_nan(val) && format_.replace_nan()) - { - os.write(format_.nan_replacement()); - } - else if (is_pos_inf(val) && format_.replace_pos_inf()) - { - os.write(format_.pos_inf_replacement()); - } - else if (is_neg_inf(val) && format_.replace_neg_inf()) - { - os.write(format_.neg_inf_replacement()); - } - //else if (format_.floatfield() != 0) - //{ - // std::basic_ostringstream<CharT> ss; - // ss.imbue(std::locale::classic()); - // ss.setf(format_.floatfield(), std::ios::floatfield); - // ss << std::showpoint << std::setprecision(format_.precision()) << val; - // os.write(ss.str()); - //} - else - { - fp_.print(val,format_.precision(),os); - } - - end_value(); - - } - - void value(int64_t val, buffered_ostream<CharT>& os) - { - begin_value(os); - - std::basic_ostringstream<CharT> ss; - ss << val; - os.write(ss.str()); - - end_value(); - } - - void value(uint64_t val, buffered_ostream<CharT>& os) - { - begin_value(os); - - std::basic_ostringstream<CharT> ss; - ss << val; - os.write(ss.str()); - - end_value(); - } - - void value(bool val, buffered_ostream<CharT>& os) - { - begin_value(os); - - if (val) - { - auto buf = json_literals<CharT>::true_literal(); - os.write(buf.first,buf.second); - } - else - { - auto buf = json_literals<CharT>::false_literal(); - os.write(buf.first,buf.second); - } - - end_value(); - } - - void do_null_value(buffered_ostream<CharT>& os) - { - begin_value(os); - auto buf = json_literals<CharT>::null_literal(); - os.write(buf.first,buf.second); - end_value(); - - } - - void begin_value(buffered_ostream<CharT>& os) - { - if (!stack_.empty()) - { - if (stack_.back().count_ > 0) - { - os.put(parameters_.field_delimiter()); - } - } - } - - void end_value() - { - if (!stack_.empty()) - { - ++stack_.back().count_; - } - } -}; - -typedef basic_csv_serializer<char> csv_serializer; - -}} - -#endif diff --git a/vendor/jsoncons-0.99.2/jsoncons_ext/jsonpath/json_query.hpp b/vendor/jsoncons-0.99.2/jsoncons_ext/jsonpath/json_query.hpp deleted file mode 100644 index 7e530abd..00000000 --- a/vendor/jsoncons-0.99.2/jsoncons_ext/jsonpath/json_query.hpp +++ /dev/null @@ -1,921 +0,0 @@ -// Copyright 2013 Daniel Parker -// Distributed under the Boost license, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -// See https://github.com/danielaparker/jsoncons for latest version - -#ifndef JSONCONS_JSONPATH_JSONQUERY_HPP -#define JSONCONS_JSONPATH_JSONQUERY_HPP - -#include <string> -#include <sstream> -#include <vector> -#include <istream> -#include <cstdlib> -#include <memory> -#include "jsoncons/json.hpp" -#include "jsonpath_filter.hpp" -#include "jsonpath_error_category.hpp" - -namespace jsoncons { namespace jsonpath { - - template<typename CharT> - bool try_string_to_index(const CharT *s, size_t length, size_t* value) - { - static const size_t max_value = std::numeric_limits<size_t>::max JSONCONS_NO_MACRO_EXP(); - static const size_t max_value_div_10 = max_value / 10; - - size_t n = 0; - for (size_t i = 0; i < length; ++i) - { - CharT c = s[i]; - switch (c) - { - case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': - { - size_t x = c - '0'; - if (n > max_value_div_10) - { - return false; - } - n = n * 10; - if (n > max_value - x) - { - return false; - } - - n += x; - } - break; - default: - return false; - break; - } - } - *value = n; - return true; - } - - template <typename CharT> - struct json_jsonpath_traits - { - }; - - template <> - struct json_jsonpath_traits<char> - { - static const std::string length_literal() {return "length";}; - }; - - template <> - struct json_jsonpath_traits<wchar_t> // assume utf16 - { - static const std::wstring length_literal() {return L"length";}; - }; - -// here - -template<class JsonT> -JsonT json_query(const JsonT& root, const typename JsonT::char_type* path, size_t length) -{ - jsonpath_evaluator<JsonT> evaluator; - evaluator.evaluate(root,path,length); - return evaluator.get_values(); -} - -template<class JsonT> -JsonT json_query(const JsonT& root, const typename JsonT::string_type& path) -{ - return json_query(root,path.data(),path.length()); -} - -template<class JsonT> -JsonT json_query(const JsonT& root, const typename JsonT::char_type* path) -{ - return json_query(root,path,std::char_traits<typename JsonT::char_type>::length(path)); -} - -enum class states -{ - start, - cr, - lf, - expect_separator, - expect_unquoted_name, - unquoted_name, - single_quoted_name, - double_quoted_name, - left_bracket, - left_bracket_start, - left_bracket_end, - left_bracket_end2, - left_bracket_step, - left_bracket_step2, - expect_right_bracket, - dot -}; - -template<class JsonT> -class jsonpath_evaluator : private basic_parsing_context<typename JsonT::char_type> -{ -private: - typedef typename JsonT::char_type char_type; - typedef typename JsonT::string_type string_type; - typedef const JsonT* cjson_ptr; - typedef std::vector<cjson_ptr> node_set; - - basic_parse_error_handler<char_type> *err_handler_; - states state_; - string_type buffer_; - size_t start_; - size_t end_; - size_t step_; - bool positive_start_; - bool positive_end_; - bool positive_step_; - bool end_undefined_; - std::vector<node_set> stack_; - bool recursive_descent_; - std::vector<cjson_ptr> nodes_; - std::vector<std::shared_ptr<JsonT>> temp_; - size_t line_; - size_t column_; - const char_type* begin_input_; - const char_type* end_input_; - const char_type* p_; - states pre_line_break_state_; - - void transfer_nodes() - { - stack_.push_back(nodes_); - nodes_.clear(); - } - -public: - jsonpath_evaluator() - : err_handler_(std::addressof(basic_default_parse_error_handler<char_type>::instance())) - { - } - - JsonT get_values() const - { - JsonT result = JsonT::make_array(); - - if (stack_.size() > 0) - { - for (size_t i = 0; i < stack_.back().size(); ++i) - { - cjson_ptr p = stack_.back()[i]; - result.add(*p); - } - } - return result; - } - - void evaluate(const JsonT& root, const string_type& path) - { - evaluate(root,path.data(),path.length()); - } - void evaluate(const JsonT& root, const char_type* path) - { - evaluate(root,path,std::char_traits<char_type>::length(path)); - } - - void evaluate(const JsonT& root, const char_type* path, size_t length) - { - begin_input_ = path; - end_input_ = path + length; - p_ = begin_input_; - - line_ = 1; - column_ = 1; - state_ = states::start; - buffer_.clear(); - start_ = 0; - end_ = 0; - step_ = 1; - recursive_descent_ = false; - positive_start_ = true; - positive_end_ = true; - positive_step_ = true; - end_undefined_ = false; - - while (p_ < end_input_) - { - switch (state_) - { - case states::cr: - ++line_; - column_ = 1; - switch (*p_) - { - case '\n': - state_ = pre_line_break_state_; - ++p_; - ++column_; - break; - default: - state_ = pre_line_break_state_; - break; - } - break; - case states::lf: - ++line_; - column_ = 1; - state_ = pre_line_break_state_; - break; - case states::start: - switch (*p_) - { - case '\r': - pre_line_break_state_ = state_; - state_ = states::cr; - break; - case '\n': - pre_line_break_state_ = state_; - state_ = states::lf; - break; - case ' ':case '\t': - ++p_; - ++column_; - break; - case '$': - case '@': - { - node_set v; - v.push_back(std::addressof(root)); - stack_.push_back(v); - state_ = states::expect_separator; - } - break; - default: - err_handler_->fatal_error(std::error_code(jsonpath_parser_errc::expected_root, jsonpath_error_category()), *this); - break; - }; - ++p_; - ++column_; - break; - case states::dot: - switch (*p_) - { - case '.': - recursive_descent_ = true; - ++p_; - ++column_; - state_ = states::expect_unquoted_name; - break; - default: - state_ = states::expect_unquoted_name; - break; - } - break; - case states::expect_unquoted_name: - switch (*p_) - { - case '\r': - pre_line_break_state_ = state_; - state_ = states::cr; - break; - case '\n': - pre_line_break_state_ = state_; - state_ = states::lf; - break; - case '.': - err_handler_->fatal_error(std::error_code(jsonpath_parser_errc::expected_name, jsonpath_error_category()), *this); - ++p_; - ++column_; - break; - case '*': - end_all(); - transfer_nodes(); - state_ = states::expect_separator; - ++p_; - ++column_; - break; - default: - state_ = states::unquoted_name; - break; - } - break; - case states::expect_separator: - switch (*p_) - { - case '\r': - pre_line_break_state_ = state_; - state_ = states::cr; - break; - case '\n': - pre_line_break_state_ = state_; - state_ = states::lf; - break; - case ' ':case '\t': - ++p_; - ++column_; - break; - case '.': - state_ = states::dot; - break; - case '[': - state_ = states::left_bracket; - break; - default: - err_handler_->fatal_error(std::error_code(jsonpath_parser_errc::expected_separator, jsonpath_error_category()), *this); - break; - }; - ++p_; - ++column_; - break; - case states::expect_right_bracket: - switch (*p_) - { - case '\r': - pre_line_break_state_ = state_; - state_ = states::cr; - break; - case '\n': - pre_line_break_state_ = state_; - state_ = states::lf; - break; - case ',': - state_ = states::left_bracket; - break; - case ']': - transfer_nodes(); - state_ = states::expect_separator; - break; - case ' ':case '\t': - break; - default: - err_handler_->fatal_error(std::error_code(jsonpath_parser_errc::expected_right_bracket, jsonpath_error_category()), *this); - break; - } - ++p_; - ++column_; - break; - case states::left_bracket_step: - switch (*p_) - { - case '\r': - pre_line_break_state_ = state_; - state_ = states::cr; - break; - case '\n': - pre_line_break_state_ = state_; - state_ = states::lf; - break; - case '-': - positive_step_ = false; - state_ = states::left_bracket_step2; - break; - case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': - step_ = static_cast<size_t>(*p_-'0'); - state_ = states::left_bracket_step2; - break; - case ']': - end_array_slice(); - transfer_nodes(); - state_ = states::expect_separator; - break; - } - ++p_; - ++column_; - break; - case states::left_bracket_step2: - switch (*p_) - { - case '\r': - pre_line_break_state_ = state_; - state_ = states::cr; - break; - case '\n': - pre_line_break_state_ = state_; - state_ = states::lf; - break; - case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': - step_ = step_*10 + static_cast<size_t>(*p_-'0'); - break; - case ']': - end_array_slice(); - transfer_nodes(); - state_ = states::expect_separator; - break; - } - ++p_; - ++column_; - break; - case states::left_bracket_end: - switch (*p_) - { - case '\r': - pre_line_break_state_ = state_; - state_ = states::cr; - break; - case '\n': - pre_line_break_state_ = state_; - state_ = states::lf; - break; - case '-': - positive_end_ = false; - state_ = states::left_bracket_end2; - break; - case ':': - step_ = 0; - state_ = states::left_bracket_step; - break; - case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': - end_undefined_ = false; - end_ = static_cast<size_t>(*p_-'0'); - state_ = states::left_bracket_end2; - break; - case ']': - end_array_slice(); - transfer_nodes(); - state_ = states::expect_separator; - break; - } - ++p_; - ++column_; - break; - case states::left_bracket_end2: - switch (*p_) - { - case '\r': - pre_line_break_state_ = state_; - state_ = states::cr; - break; - case '\n': - pre_line_break_state_ = state_; - state_ = states::lf; - break; - case ':': - step_ = 0; - state_ = states::left_bracket_step; - break; - case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': - end_undefined_ = false; - end_ = end_*10 + static_cast<size_t>(*p_-'0'); - break; - case ']': - end_array_slice(); - transfer_nodes(); - state_ = states::expect_separator; - break; - } - ++p_; - ++column_; - break; - case states::left_bracket_start: - switch (*p_) - { - case '\r': - pre_line_break_state_ = state_; - state_ = states::cr; - break; - case '\n': - pre_line_break_state_ = state_; - state_ = states::lf; - break; - case ':': - step_ = 1; - end_undefined_ = true; - state_ = states::left_bracket_end; - break; - case ',': - find_elements(); - break; - case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': - start_ = start_*10 + static_cast<size_t>(*p_-'0'); - break; - case ']': - find_elements(); - transfer_nodes(); - state_ = states::expect_separator; - break; - } - ++p_; - ++column_; - break; - case states::left_bracket: - switch (*p_) - { - case '\r': - pre_line_break_state_ = state_; - state_ = states::cr; - break; - case '\n': - pre_line_break_state_ = state_; - state_ = states::lf; - break; - case ' ':case '\t': - ++p_; - ++column_; - break; - case '(': - { - if (stack_.back().size() == 1) - { - jsonpath_filter_parser<JsonT> parser(&p_,&line_,&column_); - parser.parse(p_,end_input_); - auto index = parser.eval(*(stack_.back()[0])); - if (index.template is<size_t>()) - { - start_ = index. template as<size_t>(); - find_elements(); - } - else if (index.is_string()) - { - find(index.as_string()); - } - } - else - { - ++p_; - ++column_; - } - } - break; - case '?': - { - jsonpath_filter_parser<JsonT> parser(&p_,&line_,&column_); - parser.parse(p_,end_input_); - nodes_.clear(); - for (size_t j = 0; j < stack_.back().size(); ++j) - { - accept(*(stack_.back()[j]),parser); - } - } - break; - - case ':': - step_ = 1; - end_undefined_ = true; - state_ = states::left_bracket_end; - ++p_; - ++column_; - break; - case ',': - find_elements(); - ++p_; - ++column_; - break; - case '-': - positive_start_ = false; - state_ = states::left_bracket_start; - ++p_; - ++column_; - break; - case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': - start_ = static_cast<size_t>(*p_-'0'); - state_ = states::left_bracket_start; - ++p_; - ++column_; - break; - case ']': - //find_elements(); - transfer_nodes(); - state_ = states::expect_separator; - ++p_; - ++column_; - break; - case '*': - end_all(); - //transfer_nodes(); - state_ = states::expect_right_bracket; - ++p_; - ++column_; - break; - case '\'': - state_ = states::single_quoted_name; - ++p_; - ++column_; - break; - case '\"': - state_ = states::double_quoted_name; - ++p_; - ++column_; - break; - default: - ++p_; - ++column_; - break; - } - break; - case states::unquoted_name: - switch (*p_) - { - case '\r': - pre_line_break_state_ = state_; - state_ = states::cr; - break; - case '\n': - pre_line_break_state_ = state_; - state_ = states::lf; - break; - case '[': - find(buffer_); - buffer_.clear(); - transfer_nodes(); - start_ = 0; - state_ = states::left_bracket; - break; - case '.': - find(buffer_); - buffer_.clear(); - transfer_nodes(); - state_ = states::dot; - break; - case ' ':case '\t': - break; - default: - buffer_.push_back(*p_); - break; - }; - ++p_; - ++column_; - break; - case states::single_quoted_name: - switch (*p_) - { - case '\'': - find(buffer_); - buffer_.clear(); - state_ = states::expect_right_bracket; - break; - case '\\': - buffer_.push_back(*p_); - if (p_+1 < end_input_) - { - ++p_; - ++column_; - buffer_.push_back(*p_); - } - break; - default: - buffer_.push_back(*p_); - break; - }; - ++p_; - ++column_; - break; - case states::double_quoted_name: - switch (*p_) - { - case '\"': - find(buffer_); - buffer_.clear(); - state_ = states::expect_right_bracket; - break; - case '\\': - buffer_.push_back(*p_); - if (p_+1 < end_input_) - { - ++p_; - ++column_; - buffer_.push_back(*p_); - } - break; - default: - buffer_.push_back(*p_); - break; - }; - ++p_; - ++column_; - break; - default: - ++p_; - ++column_; - break; - } - } - switch (state_) - { - case states::unquoted_name: - { - find(buffer_); - buffer_.clear(); - transfer_nodes(); - } - break; - default: - break; - } - } - - void accept(const JsonT& val, - jsonpath_filter_parser<JsonT>& filter) - { - if (val.is_object()) - { - if (recursive_descent_ && val.is_object()) - { - for (auto it = val.members().begin(); it != val.members().end(); ++it) - { - accept(it->value(),filter); - } - } - if (filter.exists(val)) - { - nodes_.push_back(std::addressof(val)); - } - } - else if (val.is_array()) - { - for (auto it = val.elements().begin(); it != val.elements().end(); ++it) - { - accept(*it,filter); - } - } - } - - - - void end_all() - { - for (size_t i = 0; i < stack_.back().size(); ++i) - { - cjson_ptr p = stack_.back()[i]; - if (p->is_array()) - { - for (auto it = p->elements().begin(); it != p->elements().end(); ++it) - { - nodes_.push_back(std::addressof(*it)); - } - } - else if (p->is_object()) - { - for (auto it = p->members().begin(); it != p->members().end(); ++it) - { - nodes_.push_back(std::addressof(it->value())); - } - } - - } - start_ = 0; - } - - void find_elements() - { - for (size_t i = 0; i < stack_.back().size(); ++i) - { - cjson_ptr p = stack_.back()[i]; - if (p->is_array() && start_ < p->size()) - { - nodes_.push_back(std::addressof((*p)[start_])); - } - } - start_ = 0; - } - - void end_array_slice() - { - if (positive_step_) - { - end_array_slice1(); - } - else - { - end_array_slice2(); - } - start_ = 0; - end_ = 0; - step_ = 1; - positive_start_ = positive_end_ = positive_step_ = true; - end_undefined_ = true; - } - - void end_array_slice1() - { - for (size_t i = 0; i < stack_.back().size(); ++i) - { - cjson_ptr p = stack_.back()[i]; - if (p->is_array()) - { - size_t start = positive_start_ ? start_ : p->size() - start_; - size_t end; - if (!end_undefined_) - { - end = positive_end_ ? end_ : p->size() - end_; - } - else - { - end = p->size(); - } - for (size_t j = start; j < end; j += step_) - { - if (p->is_array() && j < p->size()) - { - nodes_.push_back(std::addressof((*p)[j])); - } - } - } - } - } - - void end_array_slice2() - { - for (size_t i = 0; i < stack_.back().size(); ++i) - { - cjson_ptr p = stack_.back()[i]; - size_t start = positive_start_ ? start_ : p->size() - start_; - size_t end; - if (!end_undefined_) - { - end = positive_end_ ? end_ : p->size() - end_; - } - else - { - end = p->size(); - } - - size_t j = end + step_ - 1; - while (j > (start+step_-1)) - { - j -= step_; - if (p->is_array() && j < p->size()) - { - nodes_.push_back(std::addressof((*p)[j])); - } - } - } - } - - void find(const string_type& name) - { - if (name.length() > 0) - { - for (size_t i = 0; i < stack_.back().size(); ++i) - { - find1(*(stack_.back()[i]), name); - } - recursive_descent_ = false; - } - } - - void find1(const JsonT& context_val, const string_type& name) - { - if (context_val.is_object()) - { - if (context_val.count(name) > 0) - { - nodes_.push_back(std::addressof(context_val.at(name))); - } - if (recursive_descent_) - { - for (auto it = context_val.members().begin(); it != context_val.members().end(); ++it) - { - if (it->value().is_object() || it->value().is_array()) - { - find1(it->value(), name); - } - } - } - } - else if (context_val.is_array()) - { - size_t index = 0; - if (try_string_to_index(name.data(),name.size(),&index)) - { - if (index < context_val.size()) - { - nodes_.push_back(std::addressof(context_val[index])); - } - } - else if (name == json_jsonpath_traits<char_type>::length_literal() && context_val.size() > 0) - { - auto q = std::make_shared<JsonT>(context_val.size()); - temp_.push_back(q); - nodes_.push_back(q.get()); - } - if (recursive_descent_) - { - for (auto it = context_val.elements().begin(); it != context_val.elements().end(); ++it) - { - if (it->is_object() || it->is_array()) - { - find1(*it, name); - } - } - } - } - } - - size_t do_line_number() const override - { - return line_; - } - - size_t do_column_number() const override - { - return column_; - } - - char_type do_current_char() const override - { - return 0; //p_ < end_input_? *p_ : 0; - } - -}; - -}} - -#endif diff --git a/vendor/jsoncons-0.99.2/jsoncons_ext/jsonpath/jsonpath_error_category.hpp b/vendor/jsoncons-0.99.2/jsoncons_ext/jsonpath/jsonpath_error_category.hpp deleted file mode 100644 index 7f6b6a12..00000000 --- a/vendor/jsoncons-0.99.2/jsoncons_ext/jsonpath/jsonpath_error_category.hpp +++ /dev/null @@ -1,75 +0,0 @@ -/// Copyright 2013 Daniel Parker -// Distributed under the Boost license, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -// See https://github.com/danielaparker/jsoncons for latest version - -#ifndef JSONCONS_JSONPATH_JSONPATH_ERROR_CATEGORY_HPP -#define JSONCONS_JSONPATH_JSONPATH_ERROR_CATEGORY_HPP - -#include "jsoncons/jsoncons.hpp" -#include <system_error> - -namespace jsoncons { namespace jsonpath { - -namespace jsonpath_parser_errc -{ - const int expected_root = 1; - const int expected_right_bracket = 2; - const int expected_name = 3; - const int expected_separator = 4; - const int invalid_filter = 5; - const int invalid_filter_expected_slash = 6; - const int invalid_filter_unbalanced_paren = 7; - const int invalid_filter_unsupported_operator = 8; - const int invalid_filter_expected_right_brace = 9; - const int invalid_filter_expected_primary = 10; -} - -class jsonpath_error_category_impl - : public std::error_category -{ -public: - virtual const char* name() const JSONCONS_NOEXCEPT - { - return "jsonpath"; - } - virtual std::string message(int ev) const - { - switch (ev) - { - case jsonpath_parser_errc::expected_root: - return "Expected $"; - case jsonpath_parser_errc::expected_right_bracket: - return "Expected ]"; - case jsonpath_parser_errc::expected_name: - return "Expected a name following a dot"; - case jsonpath_parser_errc::expected_separator: - return "Expected dot or left bracket separator"; - case jsonpath_parser_errc::invalid_filter: - return "Invalid path filter"; - case jsonpath_parser_errc::invalid_filter_expected_slash: - return "Invalid path filter, expected '/'"; - case jsonpath_parser_errc::invalid_filter_unbalanced_paren: - return "Invalid path filter, unbalanced parenthesis"; - case jsonpath_parser_errc::invalid_filter_unsupported_operator: - return "Unsupported operator"; - case jsonpath_parser_errc::invalid_filter_expected_right_brace: - return "Invalid path filter, expected right brace }"; - case jsonpath_parser_errc::invalid_filter_expected_primary: - return "Invalid path filter, expected primary expression."; - default: - return "Unknown jsonpath parser error"; - } - } -}; - -inline -const std::error_category& jsonpath_error_category() -{ - static jsonpath_error_category_impl instance; - return instance; -} - -}} -#endif diff --git a/vendor/jsoncons-0.99.2/jsoncons_ext/jsonpath/jsonpath_filter.hpp b/vendor/jsoncons-0.99.2/jsoncons_ext/jsonpath/jsonpath_filter.hpp deleted file mode 100644 index b0ac51c6..00000000 --- a/vendor/jsoncons-0.99.2/jsoncons_ext/jsonpath/jsonpath_filter.hpp +++ /dev/null @@ -1,1495 +0,0 @@ -// Copyright 2013 Daniel Parker -// Distributed under the Boost license, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -// See https://github.com/danielaparker/jsoncons for latest version - -#ifndef JSONCONS_JSONPATH_FILTER_HPP -#define JSONCONS_JSONPATH_FILTER_HPP - -#include <string> -#include <sstream> -#include <vector> -#include <istream> -#include <cstdlib> -#include <memory> -#include <regex> -#include "jsoncons/json.hpp" -#include "jsonpath_error_category.hpp" - -namespace jsoncons { namespace jsonpath { - -template <class JsonT> -class jsonpath_evaluator; - -enum class filter_states -{ - start, - cr, - lf, - expect_right_round_bracket, - expect_oper_or_right_round_bracket, - expect_path_or_value, - expect_regex, - regex, - single_quoted_text, - double_quoted_text, - unquoted_text, - path, - value, - oper -}; - -enum class token_types -{ - left_paren, - right_paren, - term, - eq, - ne, - regex, - ampamp, - pipepipe, - lt, - gt, - lte, - gte, - plus, - minus, - exclaim, - done -}; - -template <class JsonT> -class term -{ -public: - typedef typename JsonT::string_type string_type; - typedef typename JsonT::char_type char_type; - - virtual void initialize(const JsonT& context_node) - { - } - virtual bool accept_single_node() const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual JsonT evaluate_single_node() const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool exclaim() const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool eq(const term& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool eq(const JsonT& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool ne(const term& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool ne(const JsonT& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool regex(const term& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool regex2(const string_type& subject) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool ampamp(const term& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool ampamp(const JsonT& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool pipepipe(const term& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool pipepipe(const JsonT& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool lt(const term& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool lt(const JsonT& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool gt(const term& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual bool gt(const JsonT& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual JsonT minus(const term& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual JsonT minus(const JsonT& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual JsonT unary_minus() const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual JsonT plus(const term& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } - virtual JsonT plus(const JsonT& rhs) const - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unsupported_operator, jsonpath_error_category()),1,1); - } -}; - -template <class JsonT> -class token -{ - token_types type_; - std::shared_ptr<term<JsonT>> term_ptr_; -public: - token(token_types type) - : type_(type) - { - } - token(token_types type, std::shared_ptr<term<JsonT>> term_ptr) - : type_(type), term_ptr_(term_ptr) - { - } - token(const token& t) - : type_(t.type_), term_ptr_(t.term_ptr_) - { - } - - token_types type() const - { - return type_; - } - - std::shared_ptr<term<JsonT>> term_ptr() - { - return term_ptr_; - } - - void initialize(const JsonT& context_node) - { - if (term_ptr_.get() != nullptr) - { - term_ptr_->initialize(context_node); - } - } -}; - -template <class JsonT> -class token_stream -{ - std::vector<token<JsonT>>& tokens_; - size_t index_; -public: - token_stream(std::vector<token<JsonT>>& tokens) - : tokens_(tokens), index_(0) - { - } - - token<JsonT> get() - { - static token<JsonT> done = token<JsonT>(token_types::done); - return index_ < tokens_.size() ? tokens_[index_++] : done; - } - void putback() - { - --index_; - } -}; - -template <class JsonT> -bool ampamp(const JsonT& lhs, const JsonT& rhs) -{ - return lhs.as_bool() && rhs.as_bool(); -} - -template <class JsonT> -bool pipepipe(const JsonT& lhs, const JsonT& rhs) -{ - return lhs.as_bool() || rhs.as_bool(); -} - -template <class JsonT> -bool lt(const JsonT& lhs, const JsonT& rhs) -{ - bool result = false; - if (lhs. template is<unsigned long long>() && rhs. template is<unsigned long long>()) - { - result = lhs. template as<unsigned long long>() < rhs. template as<unsigned long long>(); - } - else if (lhs. template is<long long>() && rhs. template is<long long>()) - { - result = lhs. template as<long long>() < rhs. template as<long long>(); - } - else if ((lhs.is_number() && rhs.is_double()) || (lhs.is_double() && rhs.is_number())) - { - result = lhs.as_double() < rhs.as_double(); - } - else if (lhs.is_string() && rhs.is_string()) - { - result = lhs.as_string() < rhs.as_string(); - } - return result; -} - -template <class JsonT> -bool gt(const JsonT& lhs, const JsonT& rhs) -{ - return lt(rhs,lhs); -} - -template <class JsonT> -JsonT plus(const JsonT& lhs, const JsonT& rhs) -{ - JsonT result = jsoncons::null_type(); - if (lhs.is_integer() && rhs.is_integer()) - { - result = ((lhs.as_integer() + rhs.as_integer())); - } - else if ((lhs.is_number() && rhs.is_double()) || (lhs.is_double() && rhs.is_number())) - { - result = (lhs.as_double() + rhs.as_double()); - } - else if (lhs.is_uinteger() && rhs.is_uinteger()) - { - result = (lhs.as_uinteger() + rhs.as_uinteger()); - } - return result; -} - -template <class JsonT> -JsonT unary_minus(const JsonT& lhs) -{ - JsonT result = jsoncons::null_type(); - if (lhs.is_integer()) - { - result = -lhs.as_integer(); - } - else if (lhs.is_double()) - { - result = -lhs.as_double(); - } - return result; -} - -template <class JsonT> -JsonT minus(const JsonT& lhs, const JsonT& rhs) -{ - JsonT result = jsoncons::null_type(); - if (lhs.is_integer() && rhs.is_integer()) - { - result = ((lhs.as_integer() - rhs.as_integer())); - } - else if ((lhs.is_number() && rhs.is_double()) || (lhs.is_double() && rhs.is_number())) - { - result = (lhs.as_double() - rhs.as_double()); - } - else if (lhs.is_uinteger() && rhs.is_uinteger() && lt(rhs,lhs)) - { - result = (lhs.as_uinteger() - rhs.as_uinteger()); - } - return result; -} - -template <class JsonT> -class value_term : public term<JsonT> -{ - JsonT value_; -public: - template <class T> - value_term(const T& value) - : value_(value) - { - } - - bool accept_single_node() const override - { - return value_.as_bool(); - } - - JsonT evaluate_single_node() const override - { - return value_; - } - - bool exclaim() const override - { - return !value_.as_bool(); - } - - bool eq(const term<JsonT>& rhs) const override - { - return rhs.eq(value_); - } - - bool eq(const JsonT& rhs) const override - { - return value_ == rhs; - } - - bool ne(const term<JsonT>& rhs) const override - { - return rhs.ne(value_); - } - bool ne(const JsonT& rhs) const override - { - return value_ != rhs; - } - bool regex(const term<JsonT>& rhs) const override - { - return rhs.regex2(value_.as_string()); - } - bool ampamp(const term<JsonT>& rhs) const override - { - return rhs.ampamp(value_); - } - bool ampamp(const JsonT& rhs) const override - { - return jsoncons::jsonpath::ampamp(value_,rhs); - } - bool pipepipe(const term<JsonT>& rhs) const override - { - return rhs.pipepipe(value_); - } - bool pipepipe(const JsonT& rhs) const override - { - return jsoncons::jsonpath::pipepipe(value_,rhs); - } - - bool lt(const term<JsonT>& rhs) const override - { - return rhs.gt(value_); - } - - bool lt(const JsonT& rhs) const override - { - return jsoncons::jsonpath::lt(value_,rhs); - } - - bool gt(const term<JsonT>& rhs) const override - { - return rhs.lt(value_); - } - - bool gt(const JsonT& rhs) const override - { - return jsoncons::jsonpath::gt(value_,rhs); - } - - JsonT minus(const term<JsonT>& rhs) const override - { - return jsoncons::jsonpath::plus(rhs.unary_minus(),value_); - } - - JsonT minus(const JsonT& rhs) const override - { - return jsoncons::jsonpath::minus(value_,rhs); - } - - JsonT unary_minus() const override - { - return jsoncons::jsonpath::unary_minus(value_); - } - - JsonT plus(const term<JsonT>& rhs) const override - { - return rhs.plus(value_); - } - - JsonT plus(const JsonT& rhs) const override - { - return jsoncons::jsonpath::plus(value_,rhs); - } -}; - -template <class JsonT> -class regex_term : public term<JsonT> -{ - typedef typename JsonT::char_type char_type; - typedef typename JsonT::string_type string_type; - string_type pattern_; - std::regex::flag_type flags_; -public: - regex_term(const string_type& pattern, std::regex::flag_type flags) - : pattern_(pattern), flags_(flags) - { - } - - bool regex2(const string_type& subject) const override - { - std::basic_regex<char_type> pattern(pattern_, - flags_); - return std::regex_match(subject, pattern); - } -}; - -template <class JsonT> -class path_term : public term<JsonT> -{ - typedef typename JsonT::string_type string_type; - - string_type path_; - JsonT nodes_; -public: - path_term(const string_type& path) - : path_(path) - { - } - - void initialize(const JsonT& context_node) override - { - jsonpath_evaluator<JsonT> evaluator; - evaluator.evaluate(context_node,path_); - nodes_ = evaluator.get_values(); - } - - bool accept_single_node() const override - { - return nodes_.size() != 0; - } - - JsonT evaluate_single_node() const override - { - return nodes_.size() == 1 ? nodes_[0] : nodes_; - } - - bool exclaim() const override - { - return nodes_.size() == 0; - } - - bool eq(const term<JsonT>& rhs) const override - { - bool result = false; - if (nodes_.size() > 0) - { - result = true; - for (size_t i = 0; result && i < nodes_.size(); ++i) - { - result = rhs.eq(nodes_[i]); - } - } - return result; - } - - bool eq(const JsonT& rhs) const override - { - bool result = false; - if (nodes_.size() > 0) - { - result = true; - for (size_t i = 0; result && i < nodes_.size(); ++i) - { - result = nodes_[i] == rhs; - } - } - return result; - } - - bool ne(const term<JsonT>& rhs) const override - { - bool result = false; - if (nodes_.size() > 0) - { - result = true; - for (size_t i = 0; result && i < nodes_.size(); ++i) - { - result = rhs.ne(nodes_[i]); - } - } - return result; - - } - bool ne(const JsonT& rhs) const override - { - bool result = false; - if (nodes_.size() > 0) - { - result = true; - for (size_t i = 0; result && i < nodes_.size(); ++i) - { - result = nodes_[i] != rhs; - } - } - return result; - } - bool regex(const term<JsonT>& rhs) const override - { - bool result = false; - if (nodes_.size() > 0) - { - result = true; - for (size_t i = 0; result && i < nodes_.size(); ++i) - { - result = rhs.regex2(nodes_[i].as_string()); - } - } - return result; - } - bool ampamp(const term<JsonT>& rhs) const override - { - bool result = false; - if (nodes_.size() > 0) - { - result = true; - for (size_t i = 0; result && i < nodes_.size(); ++i) - { - result = rhs.ampamp(nodes_[i]); - } - } - return result; - } - bool ampamp(const JsonT& rhs) const override - { - bool result = false; - if (nodes_.size() > 0) - { - result = true; - for (size_t i = 0; result && i < nodes_.size(); ++i) - { - result = jsoncons::jsonpath::ampamp(nodes_[i],rhs); - } - } - return result; - } - bool pipepipe(const term<JsonT>& rhs) const override - { - bool result = false; - if (nodes_.size() > 0) - { - result = true; - for (size_t i = 0; result && i < nodes_.size(); ++i) - { - result = rhs.pipepipe(nodes_[i]); - } - } - return result; - } - bool pipepipe(const JsonT& rhs) const override - { - bool result = false; - if (nodes_.size() > 0) - { - result = true; - for (size_t i = 0; result && i < nodes_.size(); ++i) - { - result = jsoncons::jsonpath::pipepipe(nodes_[i],rhs); - } - } - return result; - } - - bool lt(const JsonT& rhs) const override - { - bool result = false; - if (nodes_.size() > 0) - { - result = true; - for (size_t i = 0; result && i < nodes_.size(); ++i) - { - result = jsoncons::jsonpath::lt(nodes_[i],rhs); - } - } - return result; - } - - bool lt(const term<JsonT>& rhs) const override - { - bool result = false; - if (nodes_.size() > 0) - { - result = true; - for (size_t i = 0; result && i < nodes_.size(); ++i) - { - result = rhs.gt(nodes_[i]); - } - } - return result; - } - - bool gt(const JsonT& rhs) const override - { - bool result = false; - if (nodes_.size() > 0) - { - result = true; - for (size_t i = 0; result && i < nodes_.size(); ++i) - { - result = jsoncons::jsonpath::gt(nodes_[i],rhs); - } - } - return result; - } - - bool gt(const term<JsonT>& rhs) const override - { - bool result = false; - if (nodes_.size() > 0) - { - result = true; - for (size_t i = 0; result && i < nodes_.size(); ++i) - { - result = rhs.lt(nodes_[i]); - } - } - return result; - } - - JsonT minus(const JsonT& rhs) const override - { - return nodes_.size() == 1 ? jsoncons::jsonpath::minus(nodes_[0],rhs) : jsoncons::null_type(); - } - - JsonT minus(const term<JsonT>& rhs) const override - { - - return nodes_.size() == 1 ? jsoncons::jsonpath::plus(rhs.unary_minus(),nodes_[0]) : jsoncons::null_type(); - } - - JsonT unary_minus() const override - { - return nodes_.size() == 1 ? jsoncons::jsonpath::unary_minus(nodes_[0]) : jsoncons::null_type(); - } - - JsonT plus(const JsonT& rhs) const override - { - static auto a_null = jsoncons::null_type(); - return nodes_.size() == 1 ? jsoncons::jsonpath::plus(nodes_[0],rhs) : a_null; - } - - JsonT plus(const term<JsonT>& rhs) const override - { - static auto a_null = jsoncons::null_type(); - return nodes_.size() == 1 ? rhs.plus(nodes_[0]) : a_null; - } -}; - -template <class JsonT> -class jsonpath_filter_parser -{ - typedef typename JsonT::string_type string_type; - typedef typename JsonT::char_type char_type; - - size_t& line_; - size_t& column_; - filter_states state_; - string_type buffer_; - std::vector<token<JsonT>> tokens_; - int depth_; - const char_type* begin_input_; - const char_type* end_input_; - const char_type*& p_; - filter_states pre_line_break_state_; -public: - jsonpath_filter_parser(const char_type** expr, size_t* line,size_t* column) - : line_(*line), column_(*column),p_(*expr) - { - } - - bool exists(const JsonT& context_node) - { - for (auto it=tokens_.begin(); it != tokens_.end(); ++it) - { - it->initialize(context_node); - } - bool result = false; - - token_stream<JsonT> ts(tokens_); - auto e = expression(ts); - result = e->accept_single_node(); - - return result; - } - - JsonT eval(const JsonT& context_node) - { - try - { - for (auto it=tokens_.begin(); it != tokens_.end(); ++it) - { - it->initialize(context_node); - } - - token_stream<JsonT> ts(tokens_); - auto e = expression(ts); - JsonT result = e->evaluate_single_node(); - - return result; - } - catch (const parse_exception& e) - { - throw parse_exception(e.code(),line_,column_); - } - } - - std::shared_ptr<term<JsonT>> primary(token_stream<JsonT>& ts) - { - auto t = ts.get(); - - switch (t.type()) - { - case token_types::left_paren: - { - auto expr = expression(ts); - t = ts.get(); - if (t.type() != token_types::right_paren) - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_expected_right_brace, jsonpath_error_category()),line_,column_); - } - return expr; - } - case token_types::term: - return t.term_ptr(); - case token_types::exclaim: - { - JsonT val = primary(ts)->exclaim(); - auto expr = std::make_shared<value_term<JsonT>>(val); - return expr; - } - case token_types::minus: - { - JsonT val = primary(ts)->unary_minus(); - auto expr = std::make_shared<value_term<JsonT>>(val); - return expr; - } - default: - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_expected_primary, jsonpath_error_category()),line_,column_); - } - } - - std::shared_ptr<term<JsonT>> expression(token_stream<JsonT>& ts) - { - auto left = make_term(ts); - auto t = ts.get(); - while (true) - { - switch (t.type()) - { - case token_types::plus: - { - JsonT val = left->plus(*(make_term(ts))); - left = std::make_shared<value_term<JsonT>>(val); - t = ts.get(); - } - break; - case token_types::minus: - { - JsonT val = left->minus(*(make_term(ts))); - left = std::make_shared<value_term<JsonT>>(val); - t = ts.get(); - } - break; - default: - ts.putback(); - return left; - } - } - return left; - } - - std::shared_ptr<term<JsonT>> make_term(token_stream<JsonT>& ts) - { - auto left = primary(ts); - auto t = ts.get(); - while (true) - { - switch (t.type()) - { - case token_types::eq: - { - bool e = left->eq(*(primary(ts))); - JsonT val(e); - left = std::make_shared<value_term<JsonT>>(val); - t = ts.get(); - } - break; - case token_types::ne: - { - bool e = left->ne(*(primary(ts))); - JsonT val(e); - left = std::make_shared<value_term<JsonT>>(val); - t = ts.get(); - } - break; - case token_types::regex: - { - bool e = left->regex(*(primary(ts))); - JsonT val(e); - left = std::make_shared<value_term<JsonT>>(val); - t = ts.get(); - } - break; - case token_types::ampamp: - { - bool e = left->ampamp(*(primary(ts))); - JsonT val(e); - left = std::make_shared<value_term<JsonT>>(val); - t = ts.get(); - } - break; - case token_types::pipepipe: - { - bool e = left->pipepipe(*(primary(ts))); - JsonT val(e); - left = std::make_shared<value_term<JsonT>>(val); - t = ts.get(); - } - break; - case token_types::lt: - { - bool e = left->lt(*(primary(ts))); - JsonT val(e); - left = std::make_shared<value_term<JsonT>>(val); - t = ts.get(); - } - break; - case token_types::gt: - { - bool e = left->gt(*(primary(ts))); - JsonT val(e); - left = std::make_shared<value_term<JsonT>>(val); - t = ts.get(); - } - break; - case token_types::lte: - { - bool e = left->lt(*(primary(ts))) || left->eq(*(primary(ts))); - JsonT val(e); - left = std::make_shared<value_term<JsonT>>(val); - t = ts.get(); - } - break; - case token_types::gte: - { - bool e = left->gt(*(primary(ts))) || left->eq(*(primary(ts))); - JsonT val(e); - left = std::make_shared<value_term<JsonT>>(val); - t = ts.get(); - } - break; - default: - ts.putback(); - return left; - } - } - } - - void parse(const char_type* expr, size_t length) - { - parse(expr,expr+length); - } - - void parse(const char_type* expr, const char_type* end_expr) - { - p_ = expr; - end_input_ = end_expr; - depth_ = 0; - tokens_.clear(); - state_ = filter_states::start; - bool done = false; - while (!done && p_ < end_input_) - { - switch (state_) - { - case filter_states::cr: - ++line_; - column_ = 1; - switch (*p_) - { - case '\n': - state_ = pre_line_break_state_; - ++p_; - ++column_; - break; - default: - state_ = pre_line_break_state_; - break; - } - break; - case filter_states::lf: - ++line_; - column_ = 1; - state_ = pre_line_break_state_; - break; - case filter_states::start: - switch (*p_) - { - case '\r': - case '\n': - pre_line_break_state_ = state_; - state_ = filter_states::lf; - break; - case '(': - state_ = filter_states::expect_path_or_value; - ++depth_; - tokens_.push_back(token<JsonT>(token_types::left_paren)); - break; - case ')': - tokens_.push_back(token<JsonT>(token_types::right_paren)); - if (--depth_ == 0) - { - done = true; - } - break; - } - ++p_; - ++column_; - break; - case filter_states::oper: - switch (*p_) - { - case '\r': - case '\n': - ++line_; - column_ = 1; - state_ = pre_line_break_state_; - break; - case '!': - if (p_+1 < end_input_ && *(p_+1) == '=') - { - ++p_; - ++column_; - state_ = filter_states::expect_path_or_value; - tokens_.push_back(token<JsonT>(token_types::ne)); - } - else - { - state_ = filter_states::expect_path_or_value; - tokens_.push_back(token<JsonT>(token_types::exclaim)); - } - break; - case '&': - if (p_+1 < end_input_ && *(p_+1) == '&') - { - ++p_; - ++column_; - state_ = filter_states::expect_path_or_value; - tokens_.push_back(token<JsonT>(token_types::ampamp)); - } - break; - case '|': - if (p_+1 < end_input_ && *(p_+1) == '|') - { - ++p_; - ++column_; - state_ = filter_states::expect_path_or_value; - tokens_.push_back(token<JsonT>(token_types::pipepipe)); - } - break; - case '=': - if (p_+1 < end_input_ && *(p_+1) == '=') - { - ++p_; - ++column_; - state_ = filter_states::expect_path_or_value; - tokens_.push_back(token<JsonT>(token_types::eq)); - } - else if (p_+1 < end_input_ && *(p_+1) == '~') - { - ++p_; - ++column_; - state_ = filter_states::expect_regex; - tokens_.push_back(token<JsonT>(token_types::regex)); - } - break; - case '>': - if (p_+1 < end_input_ && *(p_+1) == '=') - { - ++p_; - ++column_; - state_ = filter_states::expect_path_or_value; - tokens_.push_back(token<JsonT>(token_types::gte)); - } - else - { - state_ = filter_states::expect_path_or_value; - tokens_.push_back(token<JsonT>(token_types::gt)); - } - break; - case '<': - if (p_+1 < end_input_ && *(p_+1) == '=') - { - ++p_; - ++column_; - state_ = filter_states::expect_path_or_value; - tokens_.push_back(token<JsonT>(token_types::lte)); - } - else - { - state_ = filter_states::expect_path_or_value; - tokens_.push_back(token<JsonT>(token_types::lt)); - } - break; - case '+': - state_ = filter_states::expect_path_or_value; - tokens_.push_back(token<JsonT>(token_types::plus)); - break; - case '-': - state_ = filter_states::expect_path_or_value; - tokens_.push_back(token<JsonT>(token_types::minus)); - break; - case ' ':case '\t': - break; - default: - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter, jsonpath_error_category()),line_,column_); - break; - - } - ++p_; - ++column_; - break; - case filter_states::unquoted_text: - { - switch (*p_) - { - case '\r': - case '\n': - ++line_; - column_ = 1; - state_ = pre_line_break_state_; - break; - case '<': - case '>': - case '!': - case '=': - case '&': - case '|': - case '+': - case '-': - { - if (buffer_.length() > 0) - { - try - { - auto val = JsonT::parse(buffer_); - tokens_.push_back(token<JsonT>(token_types::term,std::make_shared<value_term<JsonT>>(val))); - } - catch (const parse_exception& e) - { - throw parse_exception(e.code(),line_,column_); - } - buffer_.clear(); - } - state_ = filter_states::oper; - } - break; - case ')': - if (buffer_.length() > 0) - { - try - { - auto val = JsonT::parse(buffer_); - tokens_.push_back(token<JsonT>(token_types::term,std::make_shared<value_term<JsonT>>(val))); - } - catch (const parse_exception& e) - { - throw parse_exception(e.code(),line_,column_); - } - buffer_.clear(); - } - tokens_.push_back(token<JsonT>(token_types::right_paren)); - if (--depth_ == 0) - { - state_ = filter_states::start; - done = true; - } - else - { - state_ = filter_states::expect_path_or_value; - } - ++p_; - ++column_; - break; - case ' ':case '\t': - if (buffer_.length() > 0) - { - try - { - auto val = JsonT::parse(buffer_); - tokens_.push_back(token<JsonT>(token_types::term,std::make_shared<value_term<JsonT>>(val))); - } - catch (const parse_exception& e) - { - throw parse_exception(e.code(),line_,column_); - } - buffer_.clear(); - } - ++p_; - ++column_; - break; - default: - buffer_.push_back(*p_); - ++p_; - ++column_; - break; - } - } - break; - case filter_states::single_quoted_text: - { - switch (*p_) - { - case '\r': - case '\n': - ++line_; - column_ = 1; - state_ = pre_line_break_state_; - break; - case '\\': - buffer_.push_back(*p_); - if (p_+1 < end_input_) - { - ++p_; - ++column_; - buffer_.push_back(*p_); - } - break; - case '\'': - buffer_.push_back('\"'); - //if (buffer_.length() > 0) - { - try - { - auto val = JsonT::parse(buffer_); - tokens_.push_back(token<JsonT>(token_types::term,std::make_shared<value_term<JsonT>>(val))); - } - catch (const parse_exception& e) - { - throw parse_exception(e.code(),line_,column_); - } - buffer_.clear(); - } - state_ = filter_states::expect_path_or_value; - break; - - default: - buffer_.push_back(*p_); - break; - } - } - ++p_; - ++column_; - break; - case filter_states::double_quoted_text: - { - switch (*p_) - { - case '\r': - case '\n': - ++line_; - column_ = 1; - state_ = pre_line_break_state_; - break; - case '\\': - buffer_.push_back(*p_); - if (p_+1 < end_input_) - { - ++p_; - ++column_; - buffer_.push_back(*p_); - } - break; - case '\"': - buffer_.push_back(*p_); - //if (buffer_.length() > 0) - { - try - { - auto val = JsonT::parse(buffer_); - tokens_.push_back(token<JsonT>(token_types::term,std::make_shared<value_term<JsonT>>(val))); - } - catch (const parse_exception& e) - { - throw parse_exception(e.code(),line_,column_); - } - buffer_.clear(); - } - state_ = filter_states::expect_path_or_value; - break; - - default: - buffer_.push_back(*p_); - break; - } - } - ++p_; - ++column_; - break; - case filter_states::expect_path_or_value: - switch (*p_) - { - case '\r': - case '\n': - ++line_; - column_ = 1; - state_ = pre_line_break_state_; - break; - case '<': - case '>': - case '!': - case '=': - case '&': - case '|': - case '+': - case '-': - state_ = filter_states::oper; - // don't increment - break; - case '@': - buffer_.push_back(*p_); - state_ = filter_states::path; - ++p_; - ++column_; - break; - case ' ':case '\t': - ++p_; - ++column_; - break; - case '\'': - buffer_.push_back('\"'); - state_ = filter_states::single_quoted_text; - ++p_; - ++column_; - break; - case '\"': - buffer_.push_back(*p_); - state_ = filter_states::double_quoted_text; - ++p_; - ++column_; - break; - case '(': - ++depth_; - tokens_.push_back(token<JsonT>(token_types::left_paren)); - ++p_; - ++column_; - break; - case ')': - tokens_.push_back(token<JsonT>(token_types::right_paren)); - if (--depth_ == 0) - { - done = true; - state_ = filter_states::start; - } - ++p_; - ++column_; - break; - default: - // don't increment - state_ = filter_states::unquoted_text; - break; - }; - break; - case filter_states::expect_oper_or_right_round_bracket: - switch (*p_) - { - case '\r': - case '\n': - ++line_; - column_ = 1; - state_ = pre_line_break_state_; - break; - case ' ':case '\t': - break; - case ')': - tokens_.push_back(token<JsonT>(token_types::right_paren)); - if (--depth_ == 0) - { - done = true; - state_ = filter_states::start; - } - break; - case '<': - case '>': - case '!': - case '=': - case '&': - case '|': - case '+': - case '-': - { - state_ = filter_states::oper; - // don't increment p - } - break; - default: - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter, jsonpath_error_category()),line_,column_); - break; - }; - break; - case filter_states::expect_right_round_bracket: - switch (*p_) - { - case '\r': - case '\n': - ++line_; - column_ = 1; - state_ = pre_line_break_state_; - break; - case ' ':case '\t': - break; - case ')': - tokens_.push_back(token<JsonT>(token_types::right_paren)); - if (--depth_ == 0) - { - done = true; - state_ = filter_states::start; - } - else - { - state_ = filter_states::expect_oper_or_right_round_bracket; - } - break; - default: - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter, jsonpath_error_category()),line_,column_); - break; - }; - ++p_; - ++column_; - break; - case filter_states::path: - switch (*p_) - { - case '\r': - case '\n': - ++line_; - column_ = 1; - state_ = pre_line_break_state_; - break; - case '<': - case '>': - case '!': - case '=': - case '&': - case '|': - case '+': - case '-': - { - if (buffer_.length() > 0) - { - tokens_.push_back(token<JsonT>(token_types::term,std::make_shared<path_term<JsonT>>(buffer_))); - buffer_.clear(); - } - state_ = filter_states::oper; - // don't increment - } - break; - case ')': - if (buffer_.length() > 0) - { - tokens_.push_back(token<JsonT>(token_types::term,std::make_shared<path_term<JsonT>>(buffer_))); - tokens_.push_back(token<JsonT>(token_types::right_paren)); - buffer_.clear(); - } - if (--depth_ == 0) - { - state_ = filter_states::start; - done = true; - } - else - { - state_ = filter_states::expect_path_or_value; - } - ++p_; - ++column_; - break; - default: - buffer_.push_back(*p_); - ++p_; - ++column_; - break; - }; - break; - case filter_states::expect_regex: - switch (*p_) - { - case '\r': - case '\n': - ++line_; - column_ = 1; - state_ = pre_line_break_state_; - break; - case '/': - state_ = filter_states::regex; - break; - case ' ':case '\t': - break; - default: - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_expected_slash, jsonpath_error_category()),line_,column_); - break; - }; - ++p_; - ++column_; - break; - case filter_states::regex: - { - switch (*p_) - { - case '\r': - case '\n': - ++line_; - column_ = 1; - state_ = pre_line_break_state_; - break; - case '/': - //if (buffer_.length() > 0) - { - std::regex::flag_type flags = std::regex_constants::ECMAScript; - if (p_+1 < end_input_ && *(p_+1) == 'i') - { - ++p_; - ++column_; - flags |= std::regex_constants::icase; - } - tokens_.push_back(token<JsonT>(token_types::term,std::make_shared<regex_term<JsonT>>(buffer_,flags))); - buffer_.clear(); - } - state_ = filter_states::expect_path_or_value; - break; - - default: - buffer_.push_back(*p_); - break; - } - } - ++p_; - ++column_; - break; - default: - ++p_; - ++column_; - break; - } - } - if (depth_ != 0) - { - throw parse_exception(std::error_code(jsonpath_parser_errc::invalid_filter_unbalanced_paren, jsonpath_error_category()),line_,column_); - } - } -}; - - -}} -#endif
\ No newline at end of file |