initial

2 files changed, 700 insertions, 0 deletions

diff --git a/include/jsoncons_ext/jsonpatch/jsonpatch.hpp b/include/jsoncons_ext/jsonpatch/jsonpatch.hpp
new file mode 100644
index 0000000..ab4ace7
--- /dev/null
+++ b/include/jsoncons_ext/jsonpatch/jsonpatch.hpp
@@ -0,0 +1,579 @@
+// 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_JSONPATCH_JSONPATCH_HPP
+#define JSONCONS_JSONPATCH_JSONPATCH_HPP
+
+#include <string>
+#include <vector> 
+#include <memory>
+#include <algorithm> // std::min
+#include <utility> // std::move
+#include <jsoncons/json.hpp>
+#include <jsoncons_ext/jsonpointer/jsonpointer.hpp>
+#include <jsoncons_ext/jsonpatch/jsonpatch_error.hpp>
+
+namespace jsoncons { namespace jsonpatch {
+
+namespace detail {
+
+    template <class CharT>
+    struct jsonpatch_names
+    {
+        static std::basic_string<CharT> test_name()
+        {
+            static std::basic_string<CharT> name{'t','e','s','t'};
+            return name;
+        }
+        static std::basic_string<CharT> add_name()
+        {
+            static std::basic_string<CharT> name{'a','d','d'};
+            return name;
+        }
+        static std::basic_string<CharT> remove_name()
+        {
+            static std::basic_string<CharT> name{'r','e','m','o','v','e'};
+            return name;
+        }
+        static std::basic_string<CharT> replace_name()
+        {
+            static std::basic_string<CharT> name{'r','e','p','l','a','c','e'};
+            return name;
+        }
+        static std::basic_string<CharT> move_name()
+        {
+            static std::basic_string<CharT> name{'m','o','v','e'};
+            return name;
+        }
+        static std::basic_string<CharT> copy_name()
+        {
+            static std::basic_string<CharT> name{'c','o','p','y'};
+            return name;
+        }
+        static std::basic_string<CharT> op_name()
+        {
+            static std::basic_string<CharT> name{'o','p'};
+            return name;
+        }
+        static std::basic_string<CharT> path_name()
+        {
+            static std::basic_string<CharT> name{'p','a','t','h'};
+            return name;
+        }
+        static std::basic_string<CharT> from_name()
+        {
+            static std::basic_string<CharT> name{'f','r','o','m'};
+            return name;
+        }
+        static std::basic_string<CharT> value_name()
+        {
+            static std::basic_string<CharT> name{'v','a','l','u','e'};
+            return name;
+        }
+        static std::basic_string<CharT> dash_name()
+        {
+            static std::basic_string<CharT> name{'-'};
+            return name;
+        }
+    };
+
+    template<class Json>
+    jsonpointer::basic_json_pointer<typename Json::char_type> definite_path(const Json& root, jsonpointer::basic_json_pointer<typename Json::char_type>& location)
+    {
+        using char_type = typename Json::char_type;
+        using string_type = std::basic_string<char_type>;
+
+        auto rit = location.rbegin();
+        if (rit == location.rend())
+        {
+            return location;
+        }
+
+        if (*rit != jsonpatch_names<char_type>::dash_name())
+        {
+            return location;
+        }
+
+        std::vector<string_type> tokens;
+        for (auto it = location.begin(); it != location.rbegin().base()-1; ++it)
+        {
+            tokens.push_back(*it);
+        }
+        jsonpointer::basic_json_pointer<char_type> pointer(tokens);
+
+        std::error_code ec;
+
+        Json val = jsonpointer::get(root, pointer, ec);
+        if (ec || !val.is_array())
+        {
+            return location;
+        }
+        string_type last_token;
+        jsoncons::detail::from_integer(val.size(), last_token);
+        tokens.emplace_back(std::move(last_token));
+
+        return jsonpointer::basic_json_pointer<char_type>(std::move(tokens));
+    }
+
+    enum class op_type {add,remove,replace};
+    enum class state_type {begin,abort,commit};
+
+    template <class Json>
+    struct operation_unwinder
+    {
+        using char_type = typename Json::char_type;
+        using string_type = std::basic_string<char_type>;
+        using json_pointer_type = jsonpointer::basic_json_pointer<char_type>;
+
+        struct entry
+        {
+            op_type op;
+            json_pointer_type path;
+            Json value;
+
+            entry(op_type op, const json_pointer_type& path, const Json& value)
+                : op(op), path(path), value(value)
+            {
+            }
+
+            entry(const entry&) = default;
+
+            entry(entry&&) = default;
+
+            entry& operator=(const entry&) = default;
+
+            entry& operator=(entry&&) = default;
+        };
+
+        Json& target;
+        state_type state;
+        std::vector<entry> stack;
+
+        operation_unwinder(Json& j)
+            : target(j), state(state_type::begin)
+        {
+        }
+
+        ~operation_unwinder() noexcept
+        {
+            std::error_code ec;
+            if (state != state_type::commit)
+            {
+                for (auto it = stack.rbegin(); it != stack.rend(); ++it)
+                {
+                    if (it->op == op_type::add)
+                    {
+                        jsonpointer::add(target,it->path,it->value,ec);
+                        if (ec)
+                        {
+                            //std::cout << "add: " << it->path << std::endl;
+                            break;
+                        }
+                    }
+                    else if (it->op == op_type::remove)
+                    {
+                        jsonpointer::remove(target,it->path,ec);
+                        if (ec)
+                        {
+                            //std::cout << "remove: " << it->path << std::endl;
+                            break;
+                        }
+                    }
+                    else if (it->op == op_type::replace)
+                    {
+                        jsonpointer::replace(target,it->path,it->value,ec);
+                        if (ec)
+                        {
+                            //std::cout << "replace: " << it->path << std::endl;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    template <class Json>
+    Json from_diff(const Json& source, const Json& target, const typename Json::string_view_type& path)
+    {
+        using char_type = typename Json::char_type;
+
+        Json result = typename Json::array();
+
+        if (source == target)
+        {
+            return result;
+        }
+
+        if (source.is_array() && target.is_array())
+        {
+            std::size_t common = (std::min)(source.size(),target.size());
+            for (std::size_t i = 0; i < common; ++i)
+            {
+                std::basic_string<char_type> ss(path); 
+                ss.push_back('/');
+                jsoncons::detail::from_integer(i,ss);
+                auto temp_diff = from_diff(source[i],target[i],ss);
+                result.insert(result.array_range().end(),temp_diff.array_range().begin(),temp_diff.array_range().end());
+            }
+            // Element in source, not in target - remove
+            for (std::size_t i = source.size(); i-- > target.size();)
+            {
+                std::basic_string<char_type> ss(path); 
+                ss.push_back('/');
+                jsoncons::detail::from_integer(i,ss);
+                Json val(json_object_arg);
+                val.insert_or_assign(jsonpatch_names<char_type>::op_name(), jsonpatch_names<char_type>::remove_name());
+                val.insert_or_assign(jsonpatch_names<char_type>::path_name(), ss);
+                result.push_back(std::move(val));
+            }
+            // Element in target, not in source - add, 
+            // Fix contributed by Alexander rog13
+            for (std::size_t i = source.size(); i < target.size(); ++i)
+            {
+                const auto& a = target[i];
+                std::basic_string<char_type> ss(path); 
+                ss.push_back('/');
+                jsoncons::detail::from_integer(i,ss);
+                Json val(json_object_arg);
+                val.insert_or_assign(jsonpatch_names<char_type>::op_name(), jsonpatch_names<char_type>::add_name());
+                val.insert_or_assign(jsonpatch_names<char_type>::path_name(), ss);
+                val.insert_or_assign(jsonpatch_names<char_type>::value_name(), a);
+                result.push_back(std::move(val));
+            }
+        }
+        else if (source.is_object() && target.is_object())
+        {
+            for (const auto& a : source.object_range())
+            {
+                std::basic_string<char_type> ss(path);
+                ss.push_back('/'); 
+                jsonpointer::escape(a.key(),ss);
+                auto it = target.find(a.key());
+                if (it != target.object_range().end())
+                {
+                    auto temp_diff = from_diff(a.value(),it->value(),ss);
+                    result.insert(result.array_range().end(),temp_diff.array_range().begin(),temp_diff.array_range().end());
+                }
+                else
+                {
+                    Json val(json_object_arg);
+                    val.insert_or_assign(jsonpatch_names<char_type>::op_name(), jsonpatch_names<char_type>::remove_name());
+                    val.insert_or_assign(jsonpatch_names<char_type>::path_name(), ss);
+                    result.push_back(std::move(val));
+                }
+            }
+            for (const auto& a : target.object_range())
+            {
+                auto it = source.find(a.key());
+                if (it == source.object_range().end())
+                {
+                    std::basic_string<char_type> ss(path); 
+                    ss.push_back('/');
+                    jsonpointer::escape(a.key(),ss);
+                    Json val(json_object_arg);
+                    val.insert_or_assign(jsonpatch_names<char_type>::op_name(), jsonpatch_names<char_type>::add_name());
+                    val.insert_or_assign(jsonpatch_names<char_type>::path_name(), ss);
+                    val.insert_or_assign(jsonpatch_names<char_type>::value_name(), a.value());
+                    result.push_back(std::move(val));
+                }
+            }
+        }
+        else
+        {
+            Json val(json_object_arg);
+            val.insert_or_assign(jsonpatch_names<char_type>::op_name(), jsonpatch_names<char_type>::replace_name());
+            val.insert_or_assign(jsonpatch_names<char_type>::path_name(), path);
+            val.insert_or_assign(jsonpatch_names<char_type>::value_name(), target);
+            result.push_back(std::move(val));
+        }
+
+        return result;
+    }
+}
+
+template <class Json>
+void apply_patch(Json& target, const Json& patch, std::error_code& ec)
+{
+    using char_type = typename Json::char_type;
+    using string_type = std::basic_string<char_type>;
+    using json_pointer_type = jsonpointer::basic_json_pointer<char_type>;
+
+   jsoncons::jsonpatch::detail::operation_unwinder<Json> unwinder(target);
+   std::error_code local_ec;
+
+    // Validate
+     
+    for (const auto& operation : patch.array_range())
+    {
+        unwinder.state =jsoncons::jsonpatch::detail::state_type::begin;
+
+        auto it_op = operation.find(detail::jsonpatch_names<char_type>::op_name());
+        if (it_op == operation.object_range().end())
+        {
+            ec = jsonpatch_errc::invalid_patch;
+            unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+            return;
+        }
+        string_type op = it_op->value().template as<string_type>();
+
+        auto it_path = operation.find(detail::jsonpatch_names<char_type>::path_name());
+        if (it_path == operation.object_range().end())
+        {
+            ec = jsonpatch_errc::invalid_patch;
+            unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+            return;
+        }
+        string_type path = it_path->value().template as<string_type>();
+        auto location = json_pointer_type::parse(path, local_ec);
+        if (local_ec)
+        {
+            ec = jsonpatch_errc::invalid_patch;
+            unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+            return;
+        }
+
+        if (op ==jsoncons::jsonpatch::detail::jsonpatch_names<char_type>::test_name())
+        {
+            Json val = jsonpointer::get(target,location,local_ec);
+            if (local_ec)
+            {
+                ec = jsonpatch_errc::test_failed;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+            auto it_value = operation.find(detail::jsonpatch_names<char_type>::value_name());
+            if (it_value == operation.object_range().end())
+            {
+                ec = jsonpatch_errc::invalid_patch;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+            if (val != it_value->value())
+            {
+                ec = jsonpatch_errc::test_failed;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+        }
+        else if (op ==jsoncons::jsonpatch::detail::jsonpatch_names<char_type>::add_name())
+        {
+            auto it_value = operation.find(detail::jsonpatch_names<char_type>::value_name());
+            if (it_value == operation.object_range().end())
+            {
+                ec = jsonpatch_errc::invalid_patch;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+            Json val = it_value->value();
+            auto npath = jsonpatch::detail::definite_path(target,location);
+
+            std::error_code insert_ec;
+            jsonpointer::add_if_absent(target,npath,val,insert_ec); // try insert without replace
+            if (insert_ec) // try a replace
+            {
+                std::error_code select_ec;
+                Json orig_val = jsonpointer::get(target,npath,select_ec);
+                if (select_ec) // shouldn't happen
+                {
+                    ec = jsonpatch_errc::add_failed;
+                    unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                    return;
+                }
+                std::error_code replace_ec;
+                jsonpointer::replace(target,npath,val,replace_ec);
+                if (replace_ec)
+                {
+                    ec = jsonpatch_errc::add_failed;
+                    unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                    return;
+                }
+                unwinder.stack.emplace_back(detail::op_type::replace,npath,orig_val);
+            }
+            else // insert without replace succeeded
+            {
+                unwinder.stack.emplace_back(detail::op_type::remove,npath,Json::null());
+            }
+        }
+        else if (op ==jsoncons::jsonpatch::detail::jsonpatch_names<char_type>::remove_name())
+        {
+            Json val = jsonpointer::get(target,location,local_ec);
+            if (local_ec)
+            {
+                ec = jsonpatch_errc::remove_failed;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+            jsonpointer::remove(target,location,local_ec);
+            if (local_ec)
+            {
+                ec = jsonpatch_errc::remove_failed;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+            unwinder.stack.emplace_back(detail::op_type::add, location, val);
+        }
+        else if (op ==jsoncons::jsonpatch::detail::jsonpatch_names<char_type>::replace_name())
+        {
+            Json val = jsonpointer::get(target,location,local_ec);
+            if (local_ec)
+            {
+                ec = jsonpatch_errc::replace_failed;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+            auto it_value = operation.find(detail::jsonpatch_names<char_type>::value_name());
+            if (it_value == operation.object_range().end())
+            {
+                ec = jsonpatch_errc::invalid_patch;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+            jsonpointer::replace(target, location, it_value->value(), local_ec);
+            if (local_ec)
+            {
+                ec = jsonpatch_errc::replace_failed;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+            unwinder.stack.emplace_back(detail::op_type::replace,location,val);
+        }
+        else if (op ==jsoncons::jsonpatch::detail::jsonpatch_names<char_type>::move_name())
+        {
+            auto it_from = operation.find(detail::jsonpatch_names<char_type>::from_name());
+            if (it_from == operation.object_range().end())
+            {
+                ec = jsonpatch_errc::invalid_patch;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+            string_type from = it_from->value().as_string();
+            auto from_pointer = json_pointer_type::parse(from, local_ec);
+            if (local_ec)
+            {
+                ec = jsonpatch_errc::move_failed;
+                unwinder.state = jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+
+            Json val = jsonpointer::get(target, from_pointer, local_ec);
+            if (local_ec)
+            {
+                ec = jsonpatch_errc::move_failed;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+            jsonpointer::remove(target, from_pointer, local_ec);
+            if (local_ec)
+            {
+                ec = jsonpatch_errc::move_failed;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+            unwinder.stack.emplace_back(detail::op_type::add, from_pointer, val);
+            // add
+            std::error_code insert_ec;
+            auto npath = jsonpatch::detail::definite_path(target,location);
+            jsonpointer::add_if_absent(target,npath,val,insert_ec); // try insert without replace
+            if (insert_ec) // try a replace
+            {
+                std::error_code select_ec;
+                Json orig_val = jsonpointer::get(target,npath,select_ec);
+                if (select_ec) // shouldn't happen
+                {
+                    ec = jsonpatch_errc::copy_failed;
+                    unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                    return;
+                }
+                std::error_code replace_ec;
+                jsonpointer::replace(target, npath, val, replace_ec);
+                if (replace_ec)
+                {
+                    ec = jsonpatch_errc::copy_failed;
+                    unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                    return;
+                }
+                unwinder.stack.emplace_back(jsoncons::jsonpatch::detail::op_type::replace,npath,orig_val);
+            }
+            else
+            {
+                unwinder.stack.emplace_back(detail::op_type::remove,npath,Json::null());
+            }
+        }
+        else if (op ==jsoncons::jsonpatch::detail::jsonpatch_names<char_type>::copy_name())
+        {
+            auto it_from = operation.find(detail::jsonpatch_names<char_type>::from_name());
+            if (it_from == operation.object_range().end())
+            {
+                ec = jsonpatch_errc::invalid_patch;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+            string_type from = it_from->value().as_string();
+            Json val = jsonpointer::get(target,from,local_ec);
+            if (local_ec)
+            {
+                ec = jsonpatch_errc::copy_failed;
+                unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                return;
+            }
+            // add
+            auto npath = jsonpatch::detail::definite_path(target,location);
+            std::error_code insert_ec;
+            jsonpointer::add_if_absent(target,npath,val,insert_ec); // try insert without replace
+            if (insert_ec) // Failed, try a replace
+            {
+                std::error_code select_ec;
+                Json orig_val = jsonpointer::get(target,npath, select_ec);
+                if (select_ec) // shouldn't happen
+                {
+                    ec = jsonpatch_errc::copy_failed;
+                    unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                    return;
+                }
+                std::error_code replace_ec;
+                jsonpointer::replace(target, npath, val,replace_ec);
+                if (replace_ec)
+                {
+                    ec = jsonpatch_errc::copy_failed;
+                    unwinder.state =jsoncons::jsonpatch::detail::state_type::abort;
+                    return;
+                }
+                unwinder.stack.emplace_back(jsoncons::jsonpatch::detail::op_type::replace,npath,orig_val);
+            }
+            else
+            {
+                unwinder.stack.emplace_back(detail::op_type::remove,npath,Json::null());
+            }
+        }
+    }
+    if (unwinder.state ==jsoncons::jsonpatch::detail::state_type::begin)
+    {
+        unwinder.state =jsoncons::jsonpatch::detail::state_type::commit;
+    }
+}
+
+template <class Json>
+Json from_diff(const Json& source, const Json& target)
+{
+    std::basic_string<typename Json::char_type> path;
+    return jsoncons::jsonpatch::detail::from_diff(source, target, path);
+}
+
+template <class Json>
+void apply_patch(Json& target, const Json& patch)
+{
+    std::error_code ec;
+    apply_patch(target, patch, ec);
+    if (ec)
+    {
+        JSONCONS_THROW(jsonpatch_error(ec));
+    }
+}
+
+}}
+
+#endif
diff --git a/include/jsoncons_ext/jsonpatch/jsonpatch_error.hpp b/include/jsoncons_ext/jsonpatch/jsonpatch_error.hpp
new file mode 100644
index 0000000..33f8007
--- /dev/null
+++ b/include/jsoncons_ext/jsonpatch/jsonpatch_error.hpp
@@ -0,0 +1,121 @@
+/// 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_JSONPATCH_JSONPATCH_ERROR_HPP
+#define JSONCONS_JSONPATCH_JSONPATCH_ERROR_HPP
+
+#include <jsoncons/json_exception.hpp>
+#include <system_error>
+
+namespace jsoncons { namespace jsonpatch {
+
+    enum class jsonpatch_errc 
+    {
+        success = 0,
+        invalid_patch = 1,
+        test_failed,
+        add_failed,
+        remove_failed,
+        replace_failed,
+        move_failed,
+        copy_failed
+
+    };
+
+    class jsonpatch_error_category_impl
+       : public std::error_category
+    {
+    public:
+        const char* name() const noexcept override
+        {
+            return "jsoncons/jsonpatch";
+        }
+        std::string message(int ev) const override
+        {
+            switch (static_cast<jsonpatch_errc>(ev))
+            {
+                case jsonpatch_errc::invalid_patch:
+                    return "Invalid JSON Patch document";
+                case jsonpatch_errc::test_failed:
+                    return "JSON Patch test operation failed";
+                case jsonpatch_errc::add_failed:
+                    return "JSON Patch add operation failed";
+                case jsonpatch_errc::remove_failed:
+                    return "JSON Patch remove operation failed";
+                case jsonpatch_errc::replace_failed:
+                    return "JSON Patch replace operation failed";
+                case jsonpatch_errc::move_failed:
+                    return "JSON Patch move operation failed";
+                case jsonpatch_errc::copy_failed:
+                    return "JSON Patch copy operation failed";
+                default:
+                    return "Unknown JSON Patch error";
+            }
+        }
+    };
+
+    inline
+    const std::error_category& jsonpatch_error_category()
+    {
+      static jsonpatch_error_category_impl instance;
+      return instance;
+    }
+
+    inline 
+    std::error_code make_error_code(jsonpatch_errc result)
+    {
+        return std::error_code(static_cast<int>(result),jsonpatch_error_category());
+    }
+
+} // jsonpatch
+} // jsoncons
+
+namespace std {
+    template<>
+    struct is_error_code_enum<jsoncons::jsonpatch::jsonpatch_errc> : public true_type
+    {
+    };
+}
+
+namespace jsoncons { namespace jsonpatch {
+
+// allow to disable exceptions
+#if !defined(JSONCONS_NO_EXCEPTIONS)
+    #define JSONCONS_THROW(exception) throw exception
+    #define JSONCONS_RETHROW throw
+    #define JSONCONS_TRY try
+    #define JSONCONS_CATCH(exception) catch(exception)
+#else
+    #define JSONCONS_THROW(exception) std::terminate()
+    #define JSONCONS_RETHROW std::terminate()
+    #define JSONCONS_TRY if (true)
+    #define JSONCONS_CATCH(exception) if (false)
+#endif
+
+    class jsonpatch_error : public std::system_error, public virtual json_exception
+    {
+    public:
+        jsonpatch_error(const std::error_code& ec)
+            : std::system_error(ec)
+        {
+        }
+
+        jsonpatch_error(const jsonpatch_error& other) = default;
+
+        jsonpatch_error(jsonpatch_error&& other) = default;
+
+        jsonpatch_error& operator=(const jsonpatch_error& e) = default;
+        jsonpatch_error& operator=(jsonpatch_error&& e) = default;
+
+        const char* what() const noexcept override
+        {
+            return std::system_error::what();
+        }
+    };
+} // jsonpatch
+} // jsoncons
+
+#endif