diff options
Diffstat (limited to 'include/jsoncons_ext/jsonpath/jsonpath_error.hpp')
| -rw-r--r-- | include/jsoncons_ext/jsonpath/jsonpath_error.hpp | 240 |
1 files changed, 240 insertions, 0 deletions
diff --git a/include/jsoncons_ext/jsonpath/jsonpath_error.hpp b/include/jsoncons_ext/jsonpath/jsonpath_error.hpp new file mode 100644 index 0000000..8157bba --- /dev/null +++ b/include/jsoncons_ext/jsonpath/jsonpath_error.hpp @@ -0,0 +1,240 @@ +/// Copyright 2021 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_HPP +#define JSONCONS_JSONPATH_JSONPATH_ERROR_HPP + +#include <jsoncons/json_exception.hpp> +#include <system_error> + +namespace jsoncons { namespace jsonpath { + + enum class jsonpath_errc + { + success = 0, + expected_root_or_function, + expected_current_node, + expected_rparen, + expected_rbracket, + expected_separator, + expected_forward_slash, + expected_slice_start, + expected_slice_end, + expected_slice_step, + expected_bracket_specifier_or_union, + unexpected_operator, + invalid_function_name, + invalid_argument, + invalid_arity, + function_name_not_found, + parse_error_in_filter, + argument_parse_error, + unidentified_error, + unexpected_eof, + expected_colon_dot_left_bracket_comma_or_rbracket, + argument_to_unflatten_invalid, + invalid_flattened_key, + step_cannot_be_zero, + invalid_number, + illegal_escaped_character, + invalid_codepoint, + unknown_function, + invalid_type, + unbalanced_parentheses, + syntax_error, + expected_comparator, + expected_or, + expected_and, + expected_comma_or_rparen, + expected_comma_or_rbracket, + expected_relative_path + }; + + class jsonpath_error_category_impl + : public std::error_category + { + public: + const char* name() const noexcept override + { + return "jsoncons/jsonpath"; + } + std::string message(int ev) const override + { + switch (static_cast<jsonpath_errc>(ev)) + { + case jsonpath_errc::expected_root_or_function: + return "Expected '$' or function expression"; + case jsonpath_errc::expected_current_node: + return "Expected @"; + case jsonpath_errc::expected_rbracket: + return "Expected ]"; + case jsonpath_errc::expected_rparen: + return "Expected )"; + case jsonpath_errc::expected_slice_start: + return "Expected slice start"; + case jsonpath_errc::expected_slice_end: + return "Expected slice end"; + case jsonpath_errc::expected_slice_step: + return "Expected slice step"; + case jsonpath_errc::expected_separator: + return "Expected dot or left bracket separator"; + case jsonpath_errc::expected_forward_slash: + return "Invalid path filter, expected '/'"; + case jsonpath_errc::expected_bracket_specifier_or_union: + return "Expected index, single or double quoted name, expression, filter, absolute ('$') path or relative ('@') path"; + case jsonpath_errc::invalid_function_name: + return "Invalid function name"; + case jsonpath_errc::invalid_argument: + return "Invalid argument type"; + case jsonpath_errc::invalid_arity: + return "Incorrect number of arguments"; + case jsonpath_errc::function_name_not_found: + return "Function name not found"; + case jsonpath_errc::parse_error_in_filter: + return "Could not parse JSON expression in a JSONPath filter"; + case jsonpath_errc::argument_parse_error: + return "Could not parse JSON expression passed to JSONPath function"; + case jsonpath_errc::unidentified_error: + return "Unidentified error"; + case jsonpath_errc::unexpected_eof: + return "Unexpected EOF while parsing jsonpath expression"; + case jsonpath_errc::expected_colon_dot_left_bracket_comma_or_rbracket: + return "Expected ':', '.', '[', ',', or ']'"; + case jsonpath_errc::argument_to_unflatten_invalid: + return "Argument to unflatten must be an object"; + case jsonpath_errc::invalid_flattened_key: + return "Flattened key is invalid"; + case jsonpath_errc::step_cannot_be_zero: + return "Slice step cannot be zero"; + case jsonpath_errc::invalid_number: + return "Invalid number"; + case jsonpath_errc::illegal_escaped_character: + return "Illegal escaped character"; + case jsonpath_errc::invalid_codepoint: + return "Invalid codepoint"; + case jsonpath_errc::unknown_function: + return "Unknown function"; + case jsonpath_errc::invalid_type: + return "Invalid type"; + case jsonpath_errc::unbalanced_parentheses: + return "Unbalanced parentheses"; + case jsonpath_errc::syntax_error: + return "Syntax error"; + case jsonpath_errc::expected_comparator: + return "Expected comparator"; + case jsonpath_errc::expected_or: + return "Expected operator '||'"; + case jsonpath_errc::expected_and: + return "Expected operator '&&'"; + case jsonpath_errc::expected_comma_or_rparen: + return "Expected comma or right parenthesis"; + case jsonpath_errc::expected_comma_or_rbracket: + return "Expected comma or right bracket"; + case jsonpath_errc::expected_relative_path: + return "Expected unquoted string, or single or double quoted string, or index or '*'"; + default: + return "Unknown jsonpath parser error"; + } + } + }; + + inline + const std::error_category& jsonpath_error_category() + { + static jsonpath_error_category_impl instance; + return instance; + } + + inline + std::error_code make_error_code(jsonpath_errc result) + { + return std::error_code(static_cast<int>(result),jsonpath_error_category()); + } + +} // jsonpath +} // jsoncons + +namespace std { + template<> + struct is_error_code_enum<jsoncons::jsonpath::jsonpath_errc> : public true_type + { + }; +} + +namespace jsoncons { namespace jsonpath { + + class jsonpath_error : public std::system_error, public virtual json_exception + { + std::size_t line_number_; + std::size_t column_number_; + mutable std::string what_; + public: + jsonpath_error(std::error_code ec) + : std::system_error(ec), line_number_(0), column_number_(0) + { + } + jsonpath_error(std::error_code ec, const std::string& what_arg) + : std::system_error(ec, what_arg), line_number_(0), column_number_(0) + { + } + jsonpath_error(std::error_code ec, std::size_t position) + : std::system_error(ec), line_number_(0), column_number_(position) + { + } + jsonpath_error(std::error_code ec, std::size_t line, std::size_t column) + : std::system_error(ec), line_number_(line), column_number_(column) + { + } + jsonpath_error(const jsonpath_error& other) = default; + + jsonpath_error(jsonpath_error&& other) = default; + + const char* what() const noexcept override + { + if (what_.empty()) + { + JSONCONS_TRY + { + what_.append(std::system_error::what()); + if (line_number_ != 0 && column_number_ != 0) + { + what_.append(" at line "); + what_.append(std::to_string(line_number_)); + what_.append(" and column "); + what_.append(std::to_string(column_number_)); + } + else if (column_number_ != 0) + { + what_.append(" at position "); + what_.append(std::to_string(column_number_)); + } + return what_.c_str(); + } + JSONCONS_CATCH(...) + { + return std::system_error::what(); + } + } + else + { + return what_.c_str(); + } + } + + std::size_t line() const noexcept + { + return line_number_; + } + + std::size_t column() const noexcept + { + return column_number_; + } + }; + +}} + +#endif |