jsoncons 0.1.0

data/lib/jsoncons/jsoncons/include/jsoncons/json_error.hpp

@@ -0,0 +1,156 @@
+/// 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_JSON_ERROR_HPP
+#define JSONCONS_JSON_ERROR_HPP
+
+#include <system_error>
+#include <jsoncons/config/jsoncons_config.hpp>
+
+namespace jsoncons {
+
+    enum class json_errc
+    {
+        success = 0,
+        unexpected_eof = 1,
+        source_error,
+        syntax_error,
+        extra_character,
+        max_nesting_depth_exceeded,
+        single_quote,
+        illegal_character_in_string,
+        extra_comma,
+        expected_key,
+        expected_value,
+        invalid_value,
+        expected_colon,
+        illegal_control_character,
+        illegal_escaped_character,
+        expected_codepoint_surrogate_pair,
+        invalid_hex_escape_sequence,
+        invalid_unicode_escape_sequence,
+        leading_zero,
+        invalid_number,
+        expected_comma_or_rbrace,
+        expected_comma_or_rbracket,
+        unexpected_rbracket,
+        unexpected_rbrace,
+        illegal_comment,
+        expected_continuation_byte,
+        over_long_utf8_sequence,
+        illegal_codepoint,
+        illegal_surrogate_value,
+        unpaired_high_surrogate,
+        illegal_unicode_character
+    };
+
+    class json_error_category_impl
+       : public std::error_category
+    {
+    public:
+        const char* name() const noexcept override
+        {
+            return "jsoncons/json";
+        }
+        std::string message(int ev) const override
+        {
+            switch (static_cast<json_errc>(ev))
+            {
+                case json_errc::unexpected_eof:
+                    return "Unexpected end of file";
+                case json_errc::source_error:
+                    return "Source error";
+                case json_errc::syntax_error:
+                    return "JSON syntax_error";
+                case json_errc::extra_character:
+                    return "Unexpected non-whitespace character after JSON text";
+                case json_errc::max_nesting_depth_exceeded:
+                    return "Data item nesting exceeds limit in options";
+                case json_errc::single_quote:
+                    return "JSON strings cannot be quoted with single quotes";
+                case json_errc::illegal_character_in_string:
+                    return "Illegal character in string";
+                case json_errc::extra_comma:
+                    return "Extra comma";
+                case json_errc::expected_key:
+                    return "Expected object member key";
+                case json_errc::expected_value:
+                    return "Expected value";
+                case json_errc::invalid_value:
+                    return "Invalid value";
+                case json_errc::expected_colon:
+                    return "Expected name separator ':'";
+                case json_errc::illegal_control_character:
+                    return "Illegal control character in string";
+                case json_errc::illegal_escaped_character:
+                    return "Illegal escaped character in string";
+                case json_errc::expected_codepoint_surrogate_pair:
+                    return "Invalid codepoint, expected another \\u token to begin the second half of a codepoint surrogate pair.";
+                case json_errc::invalid_hex_escape_sequence:
+                    return "Invalid codepoint, expected hexadecimal digit.";
+                case json_errc::invalid_unicode_escape_sequence:
+                    return "Invalid codepoint, expected four hexadecimal digits.";
+                case json_errc::leading_zero:
+                    return "A number cannot have a leading zero";
+                case json_errc::invalid_number:
+                    return "Invalid number";
+                case json_errc::expected_comma_or_rbrace:
+                    return "Expected comma or right brace '}'";
+                case json_errc::expected_comma_or_rbracket:
+                    return "Expected comma or right bracket ']'";
+                case json_errc::unexpected_rbrace:
+                    return "Unexpected right brace '}'";
+                case json_errc::unexpected_rbracket:
+                    return "Unexpected right bracket ']'";
+                case json_errc::illegal_comment:
+                    return "Illegal comment";
+                case json_errc::expected_continuation_byte:
+                    return "Expected continuation byte";
+                case json_errc::over_long_utf8_sequence:
+                    return "Over long UTF-8 sequence";
+                case json_errc::illegal_codepoint:
+                    return "Illegal codepoint (>= 0xd800 && <= 0xdfff)";
+                case json_errc::illegal_surrogate_value:
+                    return "UTF-16 surrogate values are illegal in UTF-32";
+                case json_errc::unpaired_high_surrogate:
+                    return "Expected low surrogate following the high surrogate";
+                case json_errc::illegal_unicode_character:
+                    return "Illegal unicode character";
+                default:
+                    return "Unknown JSON parser error";
+                }
+        }
+    };
+
+    inline
+    const std::error_category& json_error_category()
+    {
+      static json_error_category_impl instance;
+      return instance;
+    }
+
+    inline 
+    std::error_code make_error_code(json_errc result)
+    {
+        return std::error_code(static_cast<int>(result),json_error_category());
+    }
+
+#if !defined(JSONCONS_NO_DEPRECATED)
+JSONCONS_DEPRECATED_MSG("Instead, use json_errc") typedef json_errc json_parser_errc;
+
+JSONCONS_DEPRECATED_MSG("Instead, use json_errc") typedef json_errc json_parse_errc;
+#endif
+
+} // jsoncons
+
+namespace std {
+    template<>
+    struct is_error_code_enum<jsoncons::json_errc> : public true_type
+    {
+    };
+}
+
+#endif

data/lib/jsoncons/jsoncons/include/jsoncons/json_exception.hpp

@@ -0,0 +1,241 @@
+// 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 JSON_EXCEPTION_HPP
+#define JSON_EXCEPTION_HPP
+
+#include <string> // std::string
+#include <sstream> // std::ostringstream
+#include <system_error> // std::error_code
+#include <jsoncons/unicode_traits.hpp> // unicode_traits::convert
+#include <jsoncons/config/jsoncons_config.hpp>
+#include <jsoncons/traits_extension.hpp>
+
+namespace jsoncons {
+
+    // json_exception
+
+    class json_exception
+    {
+    public:
+        virtual ~json_exception() noexcept = default;
+        virtual const char* what() const noexcept = 0;
+    };
+
+    // json_runtime_error
+
+    template <class Base, class Enable = void>
+    class json_runtime_error
+    {
+    };
+
+    template <class Base>
+    class json_runtime_error<Base,
+                             typename std::enable_if<std::is_convertible<Base*,std::exception*>::value &&
+                                                     traits_extension::is_constructible_from_string<Base>::value>::type> 
+        : public Base, public virtual json_exception
+    {
+    public:
+        json_runtime_error(const std::string& s) noexcept
+            : Base(s)
+        {
+        }
+        ~json_runtime_error() noexcept
+        {
+        }
+        const char* what() const noexcept override
+        {
+            return Base::what();
+        }
+    };
+
+    class key_not_found : public std::out_of_range, public virtual json_exception
+    {
+        std::string name_;
+        mutable std::string what_;
+    public:
+        template <class CharT>
+        explicit key_not_found(const CharT* key, std::size_t length) noexcept
+            : std::out_of_range("Key not found")
+        {
+            JSONCONS_TRY
+            {
+                unicode_traits::convert(key, length, name_,
+                                 unicode_traits::conv_flags::strict);
+            }
+            JSONCONS_CATCH(...)
+            {
+            }
+        }
+
+        virtual ~key_not_found() noexcept
+        {
+        }
+
+        const char* what() const noexcept override
+        {
+            if (what_.empty())
+            {
+                JSONCONS_TRY
+                {
+                    what_.append(std::out_of_range::what());
+                    what_.append(": '");
+                    what_.append(name_);
+                    what_.append("'");
+                    return what_.c_str();
+                }
+                JSONCONS_CATCH(...)
+                {
+                    return std::out_of_range::what();
+                }
+            }
+            else
+            {
+                return what_.c_str();
+            }
+        }
+    };
+
+    class not_an_object : public std::runtime_error, public virtual json_exception
+    {
+        std::string name_;
+        mutable std::string what_;
+    public:
+        template <class CharT>
+        explicit not_an_object(const CharT* key, std::size_t length) noexcept
+            : std::runtime_error("Attempting to access a member of a value that is not an object")
+        {
+            JSONCONS_TRY
+            {
+                unicode_traits::convert(key, length, name_,
+                                 unicode_traits::conv_flags::strict);
+            }
+            JSONCONS_CATCH(...)
+            {
+            }
+        }
+
+        virtual ~not_an_object() noexcept
+        {
+        }
+        const char* what() const noexcept override
+        {
+            if (what_.empty())
+            {
+                JSONCONS_TRY
+                {
+                    what_.append(std::runtime_error::what());
+                    what_.append(": '");
+                    what_.append(name_);
+                    what_.append("'");
+                    return what_.c_str();
+                }
+                JSONCONS_CATCH(...)
+                {
+                    return std::runtime_error::what();
+                }
+            }
+            else
+            {
+                return what_.c_str();
+            }
+        }
+    };
+
+    class ser_error : public std::system_error, public virtual json_exception
+    {
+        std::size_t line_number_;
+        std::size_t column_number_;
+        mutable std::string what_;
+    public:
+        ser_error(std::error_code ec)
+            : std::system_error(ec), line_number_(0), column_number_(0)
+        {
+        }
+        ser_error(std::error_code ec, const std::string& what_arg)
+            : std::system_error(ec, what_arg), line_number_(0), column_number_(0)
+        {
+        }
+        ser_error(std::error_code ec, std::size_t position)
+            : std::system_error(ec), line_number_(0), column_number_(position)
+        {
+        }
+        ser_error(std::error_code ec, std::size_t line, std::size_t column)
+            : std::system_error(ec), line_number_(line), column_number_(column)
+        {
+        }
+        ser_error(const ser_error& other) = default;
+
+        ser_error(ser_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_;
+        }
+
+    #if !defined(JSONCONS_NO_DEPRECATED)
+        JSONCONS_DEPRECATED_MSG("Instead, use line()")
+        std::size_t line_number() const noexcept
+        {
+            return line();
+        }
+
+        JSONCONS_DEPRECATED_MSG("Instead, use column()")
+        std::size_t column_number() const noexcept
+        {
+            return column();
+        }
+    #endif
+    };
+
+#if !defined(JSONCONS_NO_DEPRECATED)
+JSONCONS_DEPRECATED_MSG("Instead, use ser_error") typedef ser_error serialization_error;
+JSONCONS_DEPRECATED_MSG("Instead, use ser_error") typedef ser_error json_parse_exception;
+JSONCONS_DEPRECATED_MSG("Instead, use ser_error") typedef ser_error parse_exception;
+JSONCONS_DEPRECATED_MSG("Instead, use ser_error") typedef ser_error parse_error;
+typedef ser_error codec_error;
+#endif
+
+} // namespace jsoncons
+
+#endif