jsoncons 0.1.0

data/lib/jsoncons/jsoncons/include/jsoncons/config/jsoncons_config.hpp

@@ -0,0 +1,309 @@
+// Copyright 2019 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_CONFIG_JSONCONS_CONFIG_HPP
+#define JSONCONS_CONFIG_JSONCONS_CONFIG_HPP
+
+#include <type_traits>
+#include <limits>
+#include <jsoncons/config/compiler_support.hpp>
+#include <jsoncons/config/binary_config.hpp>
+
+#if !defined(JSONCONS_HAS_STD_STRING_VIEW)
+#include <jsoncons/detail/string_view.hpp>
+namespace jsoncons {
+using jsoncons::detail::basic_string_view;
+using string_view = basic_string_view<char, std::char_traits<char>>;
+using wstring_view = basic_string_view<wchar_t, std::char_traits<wchar_t>>;
+}
+#else 
+#include <string_view>
+namespace jsoncons {
+using std::basic_string_view;
+using std::string_view;
+using std::wstring_view;
+}
+#endif
+
+#if !defined(JSONCONS_HAS_STD_SPAN)
+#include <jsoncons/detail/span.hpp>
+namespace jsoncons {
+using jsoncons::detail::span;
+}
+#else 
+#include <span>
+namespace jsoncons {
+using std::span;
+}
+#endif
+
+#if defined(JSONCONS_HAS_STD_OPTIONAL)
+    #include <optional>
+    namespace jsoncons {
+    using std::optional;
+    }
+#elif defined(JSONCONS_HAS_BOOST_OPTIONAL)
+    #include <boost/optional.hpp>
+    namespace jsoncons {
+    using boost::optional;
+    }
+#else 
+    #include <jsoncons/detail/optional.hpp>
+    namespace jsoncons {
+    using jsoncons::detail::optional;
+}
+#endif // !defined(JSONCONS_HAS_STD_OPTIONAL)
+
+#if !defined(JSONCONS_HAS_STD_ENDIAN)
+#include <jsoncons/detail/endian.hpp>
+namespace jsoncons {
+using jsoncons::detail::endian;
+}
+#else
+#include <bit>
+namespace jsoncons 
+{
+    using std::endian;
+}
+#endif
+
+#if !defined(JSONCONS_HAS_STD_MAKE_UNIQUE)
+
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace jsoncons {
+
+    template<class T> 
+    struct unique_if 
+    {
+        using value_is_not_array = std::unique_ptr<T>;
+    };
+
+    template<class T> 
+    struct unique_if<T[]> 
+    {
+        typedef std::unique_ptr<T[]> value_is_array_of_unknown_bound;
+    };
+
+    template<class T, std::size_t N> 
+    struct unique_if<T[N]> {
+        using value_is_array_of_known_bound = void;
+    };
+
+    template<class T, class... Args>
+    typename unique_if<T>::value_is_not_array
+    make_unique(Args&&... args) 
+    {
+        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+    }
+
+    template<class T>
+    typename unique_if<T>::value_is_array_of_unknown_bound
+    make_unique(std::size_t n) 
+    {
+        using U = typename std::remove_extent<T>::type;
+        return std::unique_ptr<T>(new U[n]());
+    }
+
+    template<class T, class... Args>
+    typename unique_if<T>::value_is_array_of_known_bound
+    make_unique(Args&&...) = delete;
+} // jsoncons
+
+#else
+
+#include <memory>
+namespace jsoncons 
+{
+    using std::make_unique;
+}
+
+#endif // !defined(JSONCONS_HAS_STD_MAKE_UNIQUE)
+
+namespace jsoncons {
+namespace binary {
+
+    // native_to_big
+
+    template<typename T, class OutputIt, class Endian=endian>
+    typename std::enable_if<Endian::native == Endian::big,void>::type
+    native_to_big(T val, OutputIt d_first)
+    {
+        uint8_t buf[sizeof(T)];
+        std::memcpy(buf, &val, sizeof(T));
+        for (auto item : buf)
+        {
+            *d_first++ = item;
+        }
+    }
+
+    template<typename T, class OutputIt, class Endian=endian>
+    typename std::enable_if<Endian::native == Endian::little,void>::type
+    native_to_big(T val, OutputIt d_first)
+    {
+        T val2 = byte_swap(val);
+        uint8_t buf[sizeof(T)];
+        std::memcpy(buf, &val2, sizeof(T));
+        for (auto item : buf)
+        {
+            *d_first++ = item;
+        }
+    }
+
+    // native_to_little
+
+    template<typename T, class OutputIt, class Endian = endian>
+    typename std::enable_if<Endian::native == Endian::little,void>::type
+    native_to_little(T val, OutputIt d_first)
+    {
+        uint8_t buf[sizeof(T)];
+        std::memcpy(buf, &val, sizeof(T));
+        for (auto item : buf)
+        {
+            *d_first++ = item;
+        }
+    }
+
+    template<typename T, class OutputIt, class Endian=endian>
+    typename std::enable_if<Endian::native == Endian::big, void>::type
+    native_to_little(T val, OutputIt d_first)
+    {
+        T val2 = byte_swap(val);
+        uint8_t buf[sizeof(T)];
+        std::memcpy(buf, &val2, sizeof(T));
+        for (auto item : buf)
+        {
+            *d_first++ = item;
+        }
+    }
+
+    // big_to_native
+
+    template<class T,class Endian=endian>
+    typename std::enable_if<Endian::native == Endian::big,T>::type
+    big_to_native(const uint8_t* first, std::size_t count)
+    {
+        if (sizeof(T) > count)
+        {
+            return T{};
+        }
+        T val;
+        std::memcpy(&val,first,sizeof(T));
+        return val;
+    }
+
+    template<class T,class Endian=endian>
+    typename std::enable_if<Endian::native == Endian::little,T>::type
+    big_to_native(const uint8_t* first, std::size_t count)
+    {
+        if (sizeof(T) > count)
+        {
+            return T{};
+        }
+        T val;
+        std::memcpy(&val,first,sizeof(T));
+        return byte_swap(val);
+    }
+
+    // little_to_native
+
+    template<class T,class Endian=endian>
+    typename std::enable_if<Endian::native == Endian::little,T>::type
+    little_to_native(const uint8_t* first, std::size_t count)
+    {
+        if (sizeof(T) > count)
+        {
+            return T{};
+        }
+        T val;
+        std::memcpy(&val,first,sizeof(T));
+        return val;
+    }
+
+    template<class T,class Endian=endian>
+    typename std::enable_if<Endian::native == Endian::big,T>::type
+    little_to_native(const uint8_t* first, std::size_t count)
+    {
+        if (sizeof(T) > count)
+        {
+            return T{};
+        }
+        T val;
+        std::memcpy(&val,first,sizeof(T));
+        return byte_swap(val);
+    }
+
+} // binary
+} // jsoncons
+
+namespace jsoncons {
+
+    template<typename CharT>
+    constexpr const CharT* cstring_constant_of_type(const char* c, const wchar_t* w);
+
+    template<> inline
+    constexpr const char* cstring_constant_of_type<char>(const char* c, const wchar_t*)
+    {
+        return c;
+    }
+    template<> inline
+    constexpr const wchar_t* cstring_constant_of_type<wchar_t>(const char*, const wchar_t* w)
+    {
+        return w;
+    }
+
+    template<typename CharT>
+    std::basic_string<CharT> string_constant_of_type(const char* c, const wchar_t* w);
+
+    template<> inline
+    std::string string_constant_of_type<char>(const char* c, const wchar_t*)
+    {
+        return std::string(c);
+    }
+    template<> inline
+    std::wstring string_constant_of_type<wchar_t>(const char*, const wchar_t* w)
+    {
+        return std::wstring(w);
+    }
+
+    template<typename CharT>
+    jsoncons::basic_string_view<CharT> string_view_constant_of_type(const char* c, const wchar_t* w);
+
+    template<> inline
+    jsoncons::string_view string_view_constant_of_type<char>(const char* c, const wchar_t*)
+    {
+        return jsoncons::string_view(c);
+    }
+    template<> inline
+    jsoncons::wstring_view string_view_constant_of_type<wchar_t>(const char*, const wchar_t* w)
+    {
+        return jsoncons::wstring_view(w);
+    }
+
+} // jsoncons
+
+#define JSONCONS_EXPAND(X) X    
+#define JSONCONS_QUOTE(Prefix, A) JSONCONS_EXPAND(Prefix ## #A)
+#define JSONCONS_WIDEN(A) JSONCONS_EXPAND(L ## A)
+
+#define JSONCONS_CSTRING_CONSTANT(CharT, Str) cstring_constant_of_type<CharT>(Str, JSONCONS_WIDEN(Str))
+#define JSONCONS_STRING_CONSTANT(CharT, Str) string_constant_of_type<CharT>(Str, JSONCONS_WIDEN(Str))
+#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) string_view_constant_of_type<CharT>(Str, JSONCONS_WIDEN(Str))
+
+#if defined(__clang__) 
+#define JSONCONS_HAS_STD_REGEX 1
+#elif (defined(__GNUC__) && (__GNUC__ == 4)) && (defined(__GNUC__) && __GNUC_MINOR__ < 9)
+// GCC 4.8 has broken regex support: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53631
+#else
+#define JSONCONS_HAS_STD_REGEX 1
+#endif
+
+#endif // JSONCONS_CONFIG_JSONCONS_CONFIG_HPP
+
+

data/lib/jsoncons/jsoncons/include/jsoncons/config/version.hpp

@@ -0,0 +1,40 @@
+// Copyright 2017 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_VERSION_HPP
+#define JSONCONS_VERSION_HPP
+ 
+#include <iostream>
+    
+#define JSONCONS_VERSION_MAJOR 0
+#define JSONCONS_VERSION_MINOR 169
+#define JSONCONS_VERSION_PATCH 0
+
+namespace jsoncons {
+
+struct versioning_info
+{
+    unsigned int const major;
+    unsigned int const minor;
+    unsigned int const patch;
+
+    friend std::ostream& operator<<(std::ostream& os, const versioning_info& ver)
+    {
+        os << ver.major << '.'
+           << ver.minor << '.'
+           << ver.patch;
+        return os;
+    }
+}; 
+
+constexpr versioning_info version()
+{
+    return versioning_info{JSONCONS_VERSION_MAJOR, JSONCONS_VERSION_MINOR, JSONCONS_VERSION_PATCH};
+}
+
+}
+
+#endif

data/lib/jsoncons/jsoncons/include/jsoncons/conv_error.hpp

@@ -0,0 +1,218 @@
+/// Copyright 2019 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_CONV_ERROR_HPP
+#define JSONCONS_CONV_ERROR_HPP
+
+#include <system_error>
+#include <jsoncons/config/jsoncons_config.hpp>
+
+namespace jsoncons {
+
+    class conv_error : public std::system_error, public virtual json_exception
+    {
+        std::size_t line_number_;
+        std::size_t column_number_;
+        mutable std::string what_;
+    public:
+        conv_error(std::error_code ec)
+            : std::system_error(ec), line_number_(0), column_number_(0)
+        {
+        }
+        conv_error(std::error_code ec, const std::string& what_arg)
+            : std::system_error(ec, what_arg), line_number_(0), column_number_(0)
+        {
+        }
+        conv_error(std::error_code ec, std::size_t position)
+            : std::system_error(ec), line_number_(0), column_number_(position)
+        {
+        }
+        conv_error(std::error_code ec, std::size_t line, std::size_t column)
+            : std::system_error(ec), line_number_(line), column_number_(column)
+        {
+        }
+        conv_error(const conv_error& other) = default;
+
+        conv_error(conv_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_;
+        }
+    };
+
+    enum class conv_errc
+    {
+        success = 0,
+        conversion_failed,
+        not_utf8,
+        not_wide_char,
+        not_vector,
+        not_array,
+        not_map,
+        not_pair,
+        not_string,
+        not_string_view,
+        not_byte_string,
+        not_byte_string_view,
+        not_integer,
+        not_signed_integer,
+        not_unsigned_integer,
+        not_bigint,
+        not_double,
+        not_bool,
+        not_variant,
+        not_nullptr,
+        not_jsoncons_null_type,
+        not_bitset,
+        not_base64,
+        not_base64url,
+        not_base16
+    };
+
+    template <class InputIt>
+    struct decode_result 
+    {
+        InputIt it;
+        conv_errc ec;
+    };
+
+#if !defined(JSONCONS_NO_DEPRECATED)
+JSONCONS_DEPRECATED_MSG("Instead, use conv_error") typedef conv_error convert_error;
+#endif
+
+} // namespace jsoncons
+
+namespace std {
+    template<>
+    struct is_error_code_enum<jsoncons::conv_errc> : public true_type
+    {
+    };
+}
+
+namespace jsoncons {
+
+namespace detail {
+    class conv_error_category_impl
+       : public std::error_category
+    {
+    public:
+        const char* name() const noexcept override
+        {
+            return "jsoncons/convert";
+        }
+        std::string message(int ev) const override
+        {
+            switch (static_cast<conv_errc>(ev))
+            {
+                case conv_errc::conversion_failed:
+                    return "Unable to convert into the provided type";
+                case conv_errc::not_utf8:
+                    return "Cannot convert string to UTF-8";
+                case conv_errc::not_wide_char:
+                    return "Cannot convert string to wide characters";
+                case conv_errc::not_vector:
+                    return "Cannot convert to vector";
+                case conv_errc::not_array:
+                    return "Cannot convert to std::array";
+                case conv_errc::not_map:
+                    return "Cannot convert to map";
+                case conv_errc::not_pair:
+                    return "Cannot convert to std::pair";
+                case conv_errc::not_string:
+                    return "Cannot convert to string";
+                case conv_errc::not_string_view:
+                    return "Cannot convert to string_view";
+                case conv_errc::not_byte_string:
+                    return "Cannot convert to byte_string";
+                case conv_errc::not_byte_string_view:
+                    return "Cannot convert to byte_string_view";
+                case conv_errc::not_integer:
+                    return "Cannot convert to integer";
+                case conv_errc::not_signed_integer:
+                    return "Cannot convert to signed integer";
+                case conv_errc::not_unsigned_integer:
+                    return "Cannot convert to unsigned integer";
+                case conv_errc::not_bigint:
+                    return "Cannot convert to bigint";
+                case conv_errc::not_double:
+                    return "Cannot convert to double";
+                case conv_errc::not_bool:
+                    return "Cannot convert to bool";
+                case conv_errc::not_variant:
+                    return "Cannot convert to std::variant";
+                case conv_errc::not_nullptr:
+                    return "Cannot convert to std::nullptr_t";
+                case conv_errc::not_jsoncons_null_type:
+                    return "Cannot convert to jsoncons::null_type";
+                case conv_errc::not_bitset:
+                    return "Cannot convert to std::bitset";
+                case conv_errc::not_base64:
+                    return "Input is not a base64 encoded string";
+                case conv_errc::not_base64url:
+                    return "Input is not a base64url encoded string";
+                case conv_errc::not_base16:
+                    return "Input is not a base16 encoded string";
+                default:
+                    return "Unknown conversion error";
+            }
+        }
+    };
+} // detail
+
+extern inline
+const std::error_category& conv_error_category()
+{
+  static detail::conv_error_category_impl instance;
+  return instance;
+}
+
+inline 
+std::error_code make_error_code(conv_errc result)
+{
+    return std::error_code(static_cast<int>(result),conv_error_category());
+}
+
+}
+
+#endif