json.hpp

/*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++
|  |  |__   |  |  | | | |  version 2.0.5
|_____|_____|_____|_|___|  https://github.com/nlohmann/json

Licensed under the MIT License <http://opensource.org/licenses/MIT>.
Copyright (c) 2013-2016 Niels Lohmann <http://nlohmann.me>.

Permission is hereby  granted, free of charge, to any  person obtaining a copy
of this software and associated  documentation files (the "Software"), to deal
in the Software  without restriction, including without  limitation the rights
to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

#ifndef NLOHMANN_JSON_HPP
#define NLOHMANN_JSON_HPP

#include <algorithm>
#include <array>
#include <cassert>
#include <ciso646>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <locale>
#include <map>
#include <memory>
#include <numeric>
#include <sstream>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>

// exclude unsupported compilers
#if defined(__clang__)
#define CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
#if CLANG_VERSION < 30400
#error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
#endif
#elif defined(__GNUC__)
#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
    #if GCC_VERSION < 40900
        #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
    #endif
#endif

// disable float-equal warnings on GCC/clang
#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif

// allow for portable deprecation warnings
#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
#define JSON_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER)
#define JSON_DEPRECATED __declspec(deprecated)
#else
    #define JSON_DEPRECATED
#endif

namespace nlohmann
{


    namespace
    {
        template<typename T>
        struct has_mapped_type
        {
            private:
                    template<typename C> static char test(typename C::mapped_type*);
            template<typename C> static char (&test(...))[2];
            public:
            static constexpr bool value = sizeof(test<T>(0)) == 1;
        };

        struct DecimalSeparator : std::numpunct<char>
        {
            char do_decimal_point() const
            {
                return '.';
            }
        };

    }

    template <
    template<typename U, typename V, typename... Args> class ObjectType = std::map,
            template<typename U, typename... Args> class ArrayType = std::vector,
            class StringType = std::string,
            class BooleanType = bool,
            class NumberIntegerType = std::int64_t,
            class NumberUnsignedType = std::uint64_t,
            class NumberFloatType = double,
    template<typename U> class AllocatorType = std::allocator
                                               >
                                               class basic_json
    {
        private:
        using basic_json_t = basic_json<ObjectType, ArrayType, StringType,
                BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType,
                AllocatorType>;

        public:
        // forward declarations
        template<typename Base> class json_reverse_iterator;
        class json_pointer;

        // container types //


        using value_type = basic_json;

        using reference = value_type&;
        using const_reference = const value_type&;

        using difference_type = std::ptrdiff_t;
        using size_type = std::size_t;

        using allocator_type = AllocatorType<basic_json>;

        using pointer = typename std::allocator_traits<allocator_type>::pointer;
        using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;

        class iterator;
        class const_iterator;
        using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
        using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;



        static allocator_type get_allocator()
        {
            return allocator_type();
        }


        // JSON value data types //


        using object_t = ObjectType<StringType,
                basic_json,
                std::less<StringType>,
                AllocatorType<std::pair<const StringType,
        basic_json>>>;

        using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;

        using string_t = StringType;

        using boolean_t = BooleanType;

        using number_integer_t = NumberIntegerType;

        using number_unsigned_t = NumberUnsignedType;

        using number_float_t = NumberFloatType;



        // JSON type enumeration //

        enum class value_t : uint8_t
        {
            null,            
                    object,          
                    array,           
                    string,          
                    boolean,         
                    number_integer,  
                    number_unsigned, 
                    number_float,    
                    discarded        
        };


        private:

        template<typename T, typename... Args>
        static T* create(Args&& ... args)
        {
            AllocatorType<T> alloc;
            auto deleter = [&](T * object)
            {
                alloc.deallocate(object, 1);
            };
            std::unique_ptr<T, decltype(deleter)> object(alloc.allocate(1), deleter);
            alloc.construct(object.get(), std::forward<Args>(args)...);
            assert(object.get() != nullptr);
            return object.release();
        }

        // JSON value storage //

        union json_value
        {
            object_t* object;
            array_t* array;
            string_t* string;
            boolean_t boolean;
            number_integer_t number_integer;
            number_unsigned_t number_unsigned;
            number_float_t number_float;

            json_value() = default;
            json_value(boolean_t v) noexcept : boolean(v) {}
            json_value(number_integer_t v) noexcept : number_integer(v) {}
            json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
            json_value(number_float_t v) noexcept : number_float(v) {}
            json_value(value_t t)
            {
                switch (t)
                {
                    case value_t::object:
                    {
                        object = create<object_t>();
                        break;
                    }

                    case value_t::array:
                    {
                        array = create<array_t>();
                        break;
                    }

                    case value_t::string:
                    {
                        string = create<string_t>("");
                        break;
                    }

                    case value_t::boolean:
                    {
                        boolean = boolean_t(false);
                        break;
                    }

                    case value_t::number_integer:
                    {
                        number_integer = number_integer_t(0);
                        break;
                    }

                    case value_t::number_unsigned:
                    {
                        number_unsigned = number_unsigned_t(0);
                        break;
                    }

                    case value_t::number_float:
                    {
                        number_float = number_float_t(0.0);
                        break;
                    }

                    default:
                    {
                        break;
                    }
                }
            }

            json_value(const string_t& value)
            {
                string = create<string_t>(value);
            }

            json_value(const object_t& value)
            {
                object = create<object_t>(value);
            }

            json_value(const array_t& value)
            {
                array = create<array_t>(value);
            }
        };

        void assert_invariant() const
        {
            assert(m_type != value_t::object or m_value.object != nullptr);
            assert(m_type != value_t::array or m_value.array != nullptr);
            assert(m_type != value_t::string or m_value.string != nullptr);
        }

        public:
        // JSON parser callback //

        enum class parse_event_t : uint8_t
        {
            object_start,
                    object_end,
                    array_start,
                    array_end,
                    key,
                    value
        };

        using parser_callback_t = std::function<bool(int depth,
        parse_event_t event,
        basic_json& parsed)>;


        // constructors //


        basic_json(const value_t value_type)
        : m_type(value_type), m_value(value_type)
        {
            assert_invariant();
        }

        basic_json(std::nullptr_t = nullptr) noexcept
        : basic_json(value_t::null)
        {
            assert_invariant();
        }

        basic_json(const object_t& val)
        : m_type(value_t::object), m_value(val)
        {
            assert_invariant();
        }

        template<class CompatibleObjectType, typename std::enable_if<
                                                      std::is_constructible<typename object_t::key_type, typename CompatibleObjectType::key_type>::value and
        std::is_constructible<basic_json, typename CompatibleObjectType::mapped_type>::value, int>::type = 0>
                                                                                                           basic_json(const CompatibleObjectType& val)
        : m_type(value_t::object)
        {
            using std::begin;
            using std::end;
            m_value.object = create<object_t>(begin(val), end(val));
            assert_invariant();
        }

        basic_json(const array_t& val)
        : m_type(value_t::array), m_value(val)
        {
            assert_invariant();
        }

        template<class CompatibleArrayType, typename std::enable_if<
                                                     not std::is_same<CompatibleArrayType, typename basic_json_t::iterator>::value and
        not std::is_same<CompatibleArrayType, typename basic_json_t::const_iterator>::value and
        not std::is_same<CompatibleArrayType, typename basic_json_t::reverse_iterator>::value and
        not std::is_same<CompatibleArrayType, typename basic_json_t::const_reverse_iterator>::value and
        not std::is_same<CompatibleArrayType, typename array_t::iterator>::value and
        not std::is_same<CompatibleArrayType, typename array_t::const_iterator>::value and
        std::is_constructible<basic_json, typename CompatibleArrayType::value_type>::value, int>::type = 0>
                                                                                                         basic_json(const CompatibleArrayType& val)
        : m_type(value_t::array)
        {
            using std::begin;
            using std::end;
            m_value.array = create<array_t>(begin(val), end(val));
            assert_invariant();
        }

        basic_json(const string_t& val)
        : m_type(value_t::string), m_value(val)
        {
            assert_invariant();
        }

        basic_json(const typename string_t::value_type* val)
        : basic_json(string_t(val))
        {
            assert_invariant();
        }

        template<class CompatibleStringType, typename std::enable_if<
        std::is_constructible<string_t, CompatibleStringType>::value, int>::type = 0>
                                                                                   basic_json(const CompatibleStringType& val)
        : basic_json(string_t(val))
        {
            assert_invariant();
        }

        basic_json(boolean_t val) noexcept
        : m_type(value_t::boolean), m_value(val)
        {
            assert_invariant();
        }

        template<typename T, typename std::enable_if<
                                      not (std::is_same<T, int>::value) and
        std::is_same<T, number_integer_t>::value, int>::type = 0>
                                                               basic_json(const number_integer_t val) noexcept
        : m_type(value_t::number_integer), m_value(val)
        {
            assert_invariant();
        }

        basic_json(const int val) noexcept
        : m_type(value_t::number_integer),
                m_value(static_cast<number_integer_t>(val))
        {
            assert_invariant();
        }

        template<typename CompatibleNumberIntegerType, typename std::enable_if<
                                                                std::is_constructible<number_integer_t, CompatibleNumberIntegerType>::value and
        std::numeric_limits<CompatibleNumberIntegerType>::is_integer and
        std::numeric_limits<CompatibleNumberIntegerType>::is_signed,
                CompatibleNumberIntegerType>::type = 0>
                                                     basic_json(const CompatibleNumberIntegerType val) noexcept
        : m_type(value_t::number_integer),
                m_value(static_cast<number_integer_t>(val))
        {
            assert_invariant();
        }

        template<typename T, typename std::enable_if<
                                      not (std::is_same<T, int>::value) and
        std::is_same<T, number_unsigned_t>::value, int>::type = 0>
                                                                basic_json(const number_unsigned_t val) noexcept
        : m_type(value_t::number_unsigned), m_value(val)
        {
            assert_invariant();
        }

        template<typename CompatibleNumberUnsignedType, typename std::enable_if <
                                                                 std::is_constructible<number_unsigned_t, CompatibleNumberUnsignedType>::value and
        std::numeric_limits<CompatibleNumberUnsignedType>::is_integer and
        not std::numeric_limits<CompatibleNumberUnsignedType>::is_signed,
        CompatibleNumberUnsignedType>::type = 0>
                                              basic_json(const CompatibleNumberUnsignedType val) noexcept
        : m_type(value_t::number_unsigned),
                m_value(static_cast<number_unsigned_t>(val))
        {
            assert_invariant();
        }

        basic_json(const number_float_t val) noexcept
        : m_type(value_t::number_float), m_value(val)
        {
            // replace infinity and NAN by null
            if (not std::isfinite(val))
            {
                m_type = value_t::null;
                m_value = json_value();
            }

            assert_invariant();
        }

        template<typename CompatibleNumberFloatType, typename = typename std::enable_if<
                                                                         std::is_constructible<number_float_t, CompatibleNumberFloatType>::value and
        std::is_floating_point<CompatibleNumberFloatType>::value>::type>
        basic_json(const CompatibleNumberFloatType val) noexcept
        : basic_json(number_float_t(val))
        {
            assert_invariant();
        }

        basic_json(std::initializer_list<basic_json> init,
                   bool type_deduction = true,
                value_t manual_type = value_t::array)
        {
            // check if each element is an array with two elements whose first
            // element is a string
            bool is_an_object = std::all_of(init.begin(), init.end(),
            [](const basic_json & element)
            {
                return element.is_array() and element.size() == 2 and element[0].is_string();
            });

            // adjust type if type deduction is not wanted
            if (not type_deduction)
            {
                // if array is wanted, do not create an object though possible
                if (manual_type == value_t::array)
                {
                    is_an_object = false;
                }

                // if object is wanted but impossible, throw an exception
                if (manual_type == value_t::object and not is_an_object)
                {
                    throw std::domain_error("cannot create object from initializer list");
                }
            }

            if (is_an_object)
            {
                // the initializer list is a list of pairs -> create object
                m_type = value_t::object;
                m_value = value_t::object;

                std::for_each(init.begin(), init.end(), [this](const basic_json & element)
                {
                    m_value.object->emplace(*(element[0].m_value.string), element[1]);
                });
            }
            else
            {
                // the initializer list describes an array -> create array
                m_type = value_t::array;
                m_value.array = create<array_t>(init);
            }

            assert_invariant();
        }

        static basic_json array(std::initializer_list<basic_json> init =
        std::initializer_list<basic_json>())
        {
            return basic_json(init, false, value_t::array);
        }

        static basic_json object(std::initializer_list<basic_json> init =
        std::initializer_list<basic_json>())
        {
            return basic_json(init, false, value_t::object);
        }

        basic_json(size_type cnt, const basic_json& val)
        : m_type(value_t::array)
        {
            m_value.array = create<array_t>(cnt, val);
            assert_invariant();
        }

        template<class InputIT, typename std::enable_if<
                                         std::is_same<InputIT, typename basic_json_t::iterator>::value or
        std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int>::type = 0>
                                                                                          basic_json(InputIT first, InputIT last)
        {
            assert(first.m_object != nullptr);
            assert(last.m_object != nullptr);

            // make sure iterator fits the current value
            if (first.m_object != last.m_object)
            {
                throw std::domain_error("iterators are not compatible");
            }

            // copy type from first iterator
            m_type = first.m_object->m_type;

            // check if iterator range is complete for primitive values
            switch (m_type)
            {
                case value_t::boolean:
                case value_t::number_float:
                case value_t::number_integer:
                case value_t::number_unsigned:
                case value_t::string:
                {
                    if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())
                    {
                        throw std::out_of_range("iterators out of range");
                    }
                    break;
                }

                default:
                {
                    break;
                }
            }

            switch (m_type)
            {
                case value_t::number_integer:
                {
                    m_value.number_integer = first.m_object->m_value.number_integer;
                    break;
                }

                case value_t::number_unsigned:
                {
                    m_value.number_unsigned = first.m_object->m_value.number_unsigned;
                    break;
                }

                case value_t::number_float:
                {
                    m_value.number_float = first.m_object->m_value.number_float;
                    break;
                }

                case value_t::boolean:
                {
                    m_value.boolean = first.m_object->m_value.boolean;
                    break;
                }

                case value_t::string:
                {
                    m_value = *first.m_object->m_value.string;
                    break;
                }

                case value_t::object:
                {
                    m_value.object = create<object_t>(first.m_it.object_iterator, last.m_it.object_iterator);
                    break;
                }

                case value_t::array:
                {
                    m_value.array = create<array_t>(first.m_it.array_iterator, last.m_it.array_iterator);
                    break;
                }

                default:
                {
                    throw std::domain_error("cannot use construct with iterators from " + first.m_object->type_name());
                }
            }

            assert_invariant();
        }

        JSON_DEPRECATED
        explicit basic_json(std::istream& i, const parser_callback_t cb = nullptr)
        {
            *this = parser(i, cb).parse();
            assert_invariant();
        }

        // other constructors and destructor //

        basic_json(const basic_json& other)
        : m_type(other.m_type)
        {
            // check of passed value is valid
            other.assert_invariant();

            switch (m_type)
            {
                case value_t::object:
                {
                    m_value = *other.m_value.object;
                    break;
                }

                case value_t::array:
                {
                    m_value = *other.m_value.array;
                    break;
                }

                case value_t::string:
                {
                    m_value = *other.m_value.string;
                    break;
                }

                case value_t::boolean:
                {
                    m_value = other.m_value.boolean;
                    break;
                }

                case value_t::number_integer:
                {
                    m_value = other.m_value.number_integer;
                    break;
                }

                case value_t::number_unsigned:
                {
                    m_value = other.m_value.number_unsigned;
                    break;
                }

                case value_t::number_float:
                {
                    m_value = other.m_value.number_float;
                    break;
                }

                default:
                {
                    break;
                }
            }

            assert_invariant();
        }

        basic_json(basic_json&& other) noexcept
        : m_type(std::move(other.m_type)),
                m_value(std::move(other.m_value))
        {
            // check that passed value is valid
            other.assert_invariant();

            // invalidate payload
            other.m_type = value_t::null;
            other.m_value = {};

            assert_invariant();
        }

        reference& operator=(basic_json other) noexcept (
                std::is_nothrow_move_constructible<value_t>::value and
        std::is_nothrow_move_assignable<value_t>::value and
        std::is_nothrow_move_constructible<json_value>::value and
        std::is_nothrow_move_assignable<json_value>::value
        )
        {
            // check that passed value is valid
            other.assert_invariant();

            using std::swap;
            swap(m_type, other.m_type);
            swap(m_value, other.m_value);

            assert_invariant();
            return *this;
        }

        ~basic_json()
        {
            assert_invariant();

            switch (m_type)
            {
                case value_t::object:
                {
                    AllocatorType<object_t> alloc;
                    alloc.destroy(m_value.object);
                    alloc.deallocate(m_value.object, 1);
                    break;
                }

                case value_t::array:
                {
                    AllocatorType<array_t> alloc;
                    alloc.destroy(m_value.array);
                    alloc.deallocate(m_value.array, 1);
                    break;
                }

                case value_t::string:
                {
                    AllocatorType<string_t> alloc;
                    alloc.destroy(m_value.string);
                    alloc.deallocate(m_value.string, 1);
                    break;
                }

                default:
                {
                    // all other types need no specific destructor
                    break;
                }
            }
        }


        public:
        // object inspection //


        string_t dump(const int indent = -1) const
        {
            std::stringstream ss;
            // fix locale problems
            const static std::locale loc(std::locale(), new DecimalSeparator);
            ss.imbue(loc);

            // 6, 15 or 16 digits of precision allows round-trip IEEE 754
            // string->float->string, string->double->string or string->long
            // double->string; to be safe, we read this value from
            // std::numeric_limits<number_float_t>::digits10
            ss.precision(std::numeric_limits<double>::digits10);

            if (indent >= 0)
            {
                dump(ss, true, static_cast<unsigned int>(indent));
            }
            else
            {
                dump(ss, false, 0);
            }

            return ss.str();
        }

        constexpr value_t type() const noexcept
        {
            return m_type;
        }

        constexpr bool is_primitive() const noexcept
        {
            return is_null() or is_string() or is_boolean() or is_number();
        }

        constexpr bool is_structured() const noexcept
        {
            return is_array() or is_object();
        }

        constexpr bool is_null() const noexcept
        {
            return m_type == value_t::null;
        }

        constexpr bool is_boolean() const noexcept
        {
            return m_type == value_t::boolean;
        }

        constexpr bool is_number() const noexcept
        {
            return is_number_integer() or is_number_float();
        }

        constexpr bool is_number_integer() const noexcept
        {
            return m_type == value_t::number_integer or m_type == value_t::number_unsigned;
        }

        constexpr bool is_number_unsigned() const noexcept
        {
            return m_type == value_t::number_unsigned;
        }

        constexpr bool is_number_float() const noexcept
        {
            return m_type == value_t::number_float;
        }

        constexpr bool is_object() const noexcept
        {
            return m_type == value_t::object;
        }

        constexpr bool is_array() const noexcept
        {
            return m_type == value_t::array;
        }

        constexpr bool is_string() const noexcept
        {
            return m_type == value_t::string;
        }

        constexpr bool is_discarded() const noexcept
        {
            return m_type == value_t::discarded;
        }

        constexpr operator value_t() const noexcept
        {
            return m_type;
        }


        private:
        // value access //

        template<class T, typename std::enable_if<
                                   std::is_convertible<typename object_t::key_type, typename T::key_type>::value and
        std::is_convertible<basic_json_t, typename T::mapped_type>::value, int>::type = 0>
                                                                                        T get_impl(T*) const
        {
            if (is_object())
            {
                return T(m_value.object->begin(), m_value.object->end());
            }
            else
            {
                throw std::domain_error("type must be object, but is " + type_name());
            }
        }

        object_t get_impl(object_t*) const
        {
            if (is_object())
            {
                return *(m_value.object);
            }
            else
            {
                throw std::domain_error("type must be object, but is " + type_name());
            }
        }

        template<class T, typename std::enable_if<
                                   std::is_convertible<basic_json_t, typename T::value_type>::value and
        not std::is_same<basic_json_t, typename T::value_type>::value and
        not std::is_arithmetic<T>::value and
        not std::is_convertible<std::string, T>::value and
        not has_mapped_type<T>::value, int>::type = 0>
                                                    T get_impl(T*) const
        {
            if (is_array())
            {
                T to_vector;
                std::transform(m_value.array->begin(), m_value.array->end(),
                               std::inserter(to_vector, to_vector.end()), [](basic_json i)
                {
                    return i.get<typename T::value_type>();
                });
                return to_vector;
            }
            else
            {
                throw std::domain_error("type must be array, but is " + type_name());
            }
        }

        template<class T, typename std::enable_if<
                                   std::is_convertible<basic_json_t, T>::value and
        not std::is_same<basic_json_t, T>::value, int>::type = 0>
                                                               std::vector<T> get_impl(std::vector<T>*) const
        {
            if (is_array())
            {
                std::vector<T> to_vector;
                to_vector.reserve(m_value.array->size());
                std::transform(m_value.array->begin(), m_value.array->end(),
                               std::inserter(to_vector, to_vector.end()), [](basic_json i)
                {
                    return i.get<T>();
                });
                return to_vector;
            }
            else
            {
                throw std::domain_error("type must be array, but is " + type_name());
            }
        }

        template<class T, typename std::enable_if<
                                   std::is_same<basic_json, typename T::value_type>::value and
        not has_mapped_type<T>::value, int>::type = 0>
                                                    T get_impl(T*) const
        {
            if (is_array())
            {
                return T(m_value.array->begin(), m_value.array->end());
            }
            else
            {
                throw std::domain_error("type must be array, but is " + type_name());
            }
        }

        array_t get_impl(array_t*) const
        {
            if (is_array())
            {
                return *(m_value.array);
            }
            else
            {
                throw std::domain_error("type must be array, but is " + type_name());
            }
        }

        template<typename T, typename std::enable_if<
        std::is_convertible<string_t, T>::value, int>::type = 0>
                                                              T get_impl(T*) const
        {
            if (is_string())
            {
                return *m_value.string;
            }
            else
            {
                throw std::domain_error("type must be string, but is " + type_name());
            }
        }

        template<typename T, typename std::enable_if<
        std::is_arithmetic<T>::value, int>::type = 0>
                                                   T get_impl(T*) const
        {
            switch (m_type)
            {
                case value_t::number_integer:
                {
                    return static_cast<T>(m_value.number_integer);
                }

                case value_t::number_unsigned:
                {
                    return static_cast<T>(m_value.number_unsigned);
                }

                case value_t::number_float:
                {
                    return static_cast<T>(m_value.number_float);
                }

                default:
                {
                    throw std::domain_error("type must be number, but is " + type_name());
                }
            }
        }

        constexpr boolean_t get_impl(boolean_t*) const
        {
            return is_boolean()
                   ? m_value.boolean
                   : throw std::domain_error("type must be boolean, but is " + type_name());
        }

        object_t* get_impl_ptr(object_t*) noexcept
        {
            return is_object() ? m_value.object : nullptr;
        }

        constexpr const object_t* get_impl_ptr(const object_t*) const noexcept
        {
            return is_object() ? m_value.object : nullptr;
        }

        array_t* get_impl_ptr(array_t*) noexcept
        {
            return is_array() ? m_value.array : nullptr;
        }

        constexpr const array_t* get_impl_ptr(const array_t*) const noexcept
        {
            return is_array() ? m_value.array : nullptr;
        }

        string_t* get_impl_ptr(string_t*) noexcept
        {
            return is_string() ? m_value.string : nullptr;
        }

        constexpr const string_t* get_impl_ptr(const string_t*) const noexcept
        {
            return is_string() ? m_value.string : nullptr;
        }

        boolean_t* get_impl_ptr(boolean_t*) noexcept
        {
            return is_boolean() ? &m_value.boolean : nullptr;
        }

        constexpr const boolean_t* get_impl_ptr(const boolean_t*) const noexcept
        {
            return is_boolean() ? &m_value.boolean : nullptr;
        }

        number_integer_t* get_impl_ptr(number_integer_t*) noexcept
        {
            return is_number_integer() ? &m_value.number_integer : nullptr;
        }

        constexpr const number_integer_t* get_impl_ptr(const number_integer_t*) const noexcept
        {
            return is_number_integer() ? &m_value.number_integer : nullptr;
        }

        number_unsigned_t* get_impl_ptr(number_unsigned_t*) noexcept
        {
            return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
        }

        constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t*) const noexcept
        {
            return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
        }

        number_float_t* get_impl_ptr(number_float_t*) noexcept
        {
            return is_number_float() ? &m_value.number_float : nullptr;
        }

        constexpr const number_float_t* get_impl_ptr(const number_float_t*) const noexcept
        {
            return is_number_float() ? &m_value.number_float : nullptr;
        }

        template<typename ReferenceType, typename ThisType>
        static ReferenceType get_ref_impl(ThisType& obj)
        {
            // helper type
            using PointerType = typename std::add_pointer<ReferenceType>::type;

            // delegate the call to get_ptr<>()
            auto ptr = obj.template get_ptr<PointerType>();

            if (ptr != nullptr)
            {
                return *ptr;
            }
            else
            {
                throw std::domain_error("incompatible ReferenceType for get_ref, actual type is " +
                                        obj.type_name());
            }
        }

        public:


        template<typename ValueType, typename std::enable_if<
                                              not std::is_pointer<ValueType>::value, int>::type = 0>
                                                                                                  ValueType get() const
        {
            return get_impl(static_cast<ValueType*>(nullptr));
        }

        template<typename PointerType, typename std::enable_if<
        std::is_pointer<PointerType>::value, int>::type = 0>
                                                          PointerType get() noexcept
        {
            // delegate the call to get_ptr
            return get_ptr<PointerType>();
        }

        template<typename PointerType, typename std::enable_if<
        std::is_pointer<PointerType>::value, int>::type = 0>
                                                          constexpr const PointerType get() const noexcept
        {
            // delegate the call to get_ptr
            return get_ptr<PointerType>();
        }

        template<typename PointerType, typename std::enable_if<
        std::is_pointer<PointerType>::value, int>::type = 0>
                                                          PointerType get_ptr() noexcept
        {
            // get the type of the PointerType (remove pointer and const)
            using pointee_t = typename std::remove_const<typename
            std::remove_pointer<typename
            std::remove_const<PointerType>::type>::type>::type;
            // make sure the type matches the allowed types
            static_assert(
                    std::is_same<object_t, pointee_t>::value
            or std::is_same<array_t, pointee_t>::value
            or std::is_same<string_t, pointee_t>::value
            or std::is_same<boolean_t, pointee_t>::value
            or std::is_same<number_integer_t, pointee_t>::value
            or std::is_same<number_unsigned_t, pointee_t>::value
            or std::is_same<number_float_t, pointee_t>::value
                    , "incompatible pointer type");

            // delegate the call to get_impl_ptr<>()
            return get_impl_ptr(static_cast<PointerType>(nullptr));
        }

        template<typename PointerType, typename std::enable_if<
                                                std::is_pointer<PointerType>::value and
        std::is_const<typename std::remove_pointer<PointerType>::type>::value, int>::type = 0>
                                                                                            constexpr const PointerType get_ptr() const noexcept
        {
            // get the type of the PointerType (remove pointer and const)
            using pointee_t = typename std::remove_const<typename
            std::remove_pointer<typename
            std::remove_const<PointerType>::type>::type>::type;
            // make sure the type matches the allowed types
            static_assert(
                    std::is_same<object_t, pointee_t>::value
            or std::is_same<array_t, pointee_t>::value
            or std::is_same<string_t, pointee_t>::value
            or std::is_same<boolean_t, pointee_t>::value
            or std::is_same<number_integer_t, pointee_t>::value
            or std::is_same<number_unsigned_t, pointee_t>::value
            or std::is_same<number_float_t, pointee_t>::value
                    , "incompatible pointer type");

            // delegate the call to get_impl_ptr<>() const
            return get_impl_ptr(static_cast<const PointerType>(nullptr));
        }

        template<typename ReferenceType, typename std::enable_if<
        std::is_reference<ReferenceType>::value, int>::type = 0>
                                                              ReferenceType get_ref()
        {
            // delegate call to get_ref_impl
            return get_ref_impl<ReferenceType>(*this);
        }

        template<typename ReferenceType, typename std::enable_if<
                                                  std::is_reference<ReferenceType>::value and
        std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int>::type = 0>
                                                                                                ReferenceType get_ref() const
        {
            // delegate call to get_ref_impl
            return get_ref_impl<ReferenceType>(*this);
        }

        template < typename ValueType, typename std::enable_if <
                                                not std::is_pointer<ValueType>::value and
        not std::is_same<ValueType, typename string_t::value_type>::value
#ifndef _MSC_VER  // Fix for issue #167 operator<< abiguity under VS2015
        and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
#endif
                , int >::type = 0 >
                                operator ValueType() const
        {
            // delegate the call to get<>() const
            return get<ValueType>();
        }



        // element access //


        reference at(size_type idx)
        {
            // at only works for arrays
            if (is_array())
            {
                try
                {
                    return m_value.array->at(idx);
                }
                catch (std::out_of_range&)
                {
                    // create better exception explanation
                    throw std::out_of_range("array index " + std::to_string(idx) + " is out of range");
                }
            }
            else
            {
                throw std::domain_error("cannot use at() with " + type_name());
            }
        }

        const_reference at(size_type idx) const
        {
            // at only works for arrays
            if (is_array())
            {
                try
                {
                    return m_value.array->at(idx);
                }
                catch (std::out_of_range&)
                {
                    // create better exception explanation
                    throw std::out_of_range("array index " + std::to_string(idx) + " is out of range");
                }
            }
            else
            {
                throw std::domain_error("cannot use at() with " + type_name());
            }
        }

        reference at(const typename object_t::key_type& key)
        {
            // at only works for objects
            if (is_object())
            {
                try
                {
                    return m_value.object->at(key);
                }
                catch (std::out_of_range&)
                {
                    // create better exception explanation
                    throw std::out_of_range("key '" + key + "' not found");
                }
            }
            else
            {
                throw std::domain_error("cannot use at() with " + type_name());
            }
        }

        const_reference at(const typename object_t::key_type& key) const
        {
            // at only works for objects
            if (is_object())
            {
                try
                {
                    return m_value.object->at(key);
                }
                catch (std::out_of_range&)
                {
                    // create better exception explanation
                    throw std::out_of_range("key '" + key + "' not found");
                }
            }
            else
            {
                throw std::domain_error("cannot use at() with " + type_name());
            }
        }

        reference operator[](size_type idx)
        {
            // implicitly convert null value to an empty array
            if (is_null())
            {
                m_type = value_t::array;
                m_value.array = create<array_t>();
                assert_invariant();
            }

            // operator[] only works for arrays
            if (is_array())
            {
                // fill up array with null values if given idx is outside range
                if (idx >= m_value.array->size())
                {
                    m_value.array->insert(m_value.array->end(),
                                          idx - m_value.array->size() + 1,
                                          basic_json());
                }

                return m_value.array->operator[](idx);
            }
            else
            {
                throw std::domain_error("cannot use operator[] with " + type_name());
            }
        }

        const_reference operator[](size_type idx) const
        {
            // const operator[] only works for arrays
            if (is_array())
            {
                return m_value.array->operator[](idx);
            }
            else
            {
                throw std::domain_error("cannot use operator[] with " + type_name());
            }
        }

        reference operator[](const typename object_t::key_type& key)
        {
            // implicitly convert null value to an empty object
            if (is_null())
            {
                m_type = value_t::object;
                m_value.object = create<object_t>();
                assert_invariant();
            }

            // operator[] only works for objects
            if (is_object())
            {
                return m_value.object->operator[](key);
            }
            else
            {
                throw std::domain_error("cannot use operator[] with " + type_name());
            }
        }

        const_reference operator[](const typename object_t::key_type& key) const
        {
            // const operator[] only works for objects
            if (is_object())
            {
                assert(m_value.object->find(key) != m_value.object->end());
                return m_value.object->find(key)->second;
            }
            else
            {
                throw std::domain_error("cannot use operator[] with " + type_name());
            }
        }

        template<typename T, std::size_t n>
                                         reference operator[](T * (&key)[n])
        {
            return operator[](static_cast<const T>(key));
        }

        template<typename T, std::size_t n>
                                         const_reference operator[](T * (&key)[n]) const
        {
            return operator[](static_cast<const T>(key));
        }

        template<typename T>
                          reference operator[](T* key)
        {
            // implicitly convert null to object
            if (is_null())
            {
                m_type = value_t::object;
                m_value = value_t::object;
                assert_invariant();
            }

            // at only works for objects
            if (is_object())
            {
                return m_value.object->operator[](key);
            }
            else
            {
                throw std::domain_error("cannot use operator[] with " + type_name());
            }
        }

        template<typename T>
                          const_reference operator[](T* key) const
        {
            // at only works for objects
            if (is_object())
            {
                assert(m_value.object->find(key) != m_value.object->end());
                return m_value.object->find(key)->second;
            }
            else
            {
                throw std::domain_error("cannot use operator[] with " + type_name());
            }
        }

        template<class ValueType, typename std::enable_if<
        std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
                                                                          ValueType value(const typename object_t::key_type& key, ValueType default_value) const
        {
            // at only works for objects
            if (is_object())
            {
                // if key is found, return value and given default value otherwise
                const auto it = find(key);
                if (it != end())
                {
                    return *it;
                }
                else
                {
                    return default_value;
                }
            }
            else
            {
                throw std::domain_error("cannot use value() with " + type_name());
            }
        }

        string_t value(const typename object_t::key_type& key, const char* default_value) const
        {
            return value(key, string_t(default_value));
        }

        template<class ValueType, typename std::enable_if<
        std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
                                                                          ValueType value(const json_pointer& ptr, ValueType default_value) const
        {
            // at only works for objects
            if (is_object())
            {
                // if pointer resolves a value, return it or use default value
                try
                {
                    return ptr.get_checked(this);
                }
                catch (std::out_of_range&)
                {
                    return default_value;
                }
            }
            else
            {
                throw std::domain_error("cannot use value() with " + type_name());
            }
        }

        string_t value(const json_pointer& ptr, const char* default_value) const
        {
            return value(ptr, string_t(default_value));
        }

        reference front()
        {
            return *begin();
        }

        const_reference front() const
        {
            return *cbegin();
        }

        reference back()
        {
            auto tmp = end();
            --tmp;
            return *tmp;
        }

        const_reference back() const
        {
            auto tmp = cend();
            --tmp;
            return *tmp;
        }

        template<class IteratorType, typename std::enable_if<
                                              std::is_same<IteratorType, typename basic_json_t::iterator>::value or
        std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
                                                                                              = 0>
                                                                                                IteratorType erase(IteratorType pos)
        {
            // make sure iterator fits the current value
            if (this != pos.m_object)
            {
                throw std::domain_error("iterator does not fit current value");
            }

            IteratorType result = end();

            switch (m_type)
            {
                case value_t::boolean:
                case value_t::number_float:
                case value_t::number_integer:
                case value_t::number_unsigned:
                case value_t::string:
                {
                    if (not pos.m_it.primitive_iterator.is_begin())
                    {
                        throw std::out_of_range("iterator out of range");
                    }

                    if (is_string())
                    {
                        AllocatorType<string_t> alloc;
                        alloc.destroy(m_value.string);
                        alloc.deallocate(m_value.string, 1);
                        m_value.string = nullptr;
                    }

                    m_type = value_t::null;
                    assert_invariant();
                    break;
                }

                case value_t::object:
                {
                    result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
                    break;
                }

                case value_t::array:
                {
                    result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
                    break;
                }

                default:
                {
                    throw std::domain_error("cannot use erase() with " + type_name());
                }
            }

            return result;
        }

        template<class IteratorType, typename std::enable_if<
                                              std::is_same<IteratorType, typename basic_json_t::iterator>::value or
        std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
                                                                                              = 0>
                                                                                                IteratorType erase(IteratorType first, IteratorType last)
        {
            // make sure iterator fits the current value
            if (this != first.m_object or this != last.m_object)
            {
                throw std::domain_error("iterators do not fit current value");
            }

            IteratorType result = end();

            switch (m_type)
            {
                case value_t::boolean:
                case value_t::number_float:
                case value_t::number_integer:
                case value_t::number_unsigned:
                case value_t::string:
                {
                    if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())
                    {
                        throw std::out_of_range("iterators out of range");
                    }

                    if (is_string())
                    {
                        AllocatorType<string_t> alloc;
                        alloc.destroy(m_value.string);
                        alloc.deallocate(m_value.string, 1);
                        m_value.string = nullptr;
                    }

                    m_type = value_t::null;
                    assert_invariant();
                    break;
                }

                case value_t::object:
                {
                    result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
                                                                        last.m_it.object_iterator);
                    break;
                }

                case value_t::array:
                {
                    result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
                                                                      last.m_it.array_iterator);
                    break;
                }

                default:
                {
                    throw std::domain_error("cannot use erase() with " + type_name());
                }
            }

            return result;
        }

        size_type erase(const typename object_t::key_type& key)
        {
            // this erase only works for objects
            if (is_object())
            {
                return m_value.object->erase(key);
            }
            else
            {
                throw std::domain_error("cannot use erase() with " + type_name());
            }
        }

        void erase(const size_type idx)
        {
            // this erase only works for arrays
            if (is_array())
            {
                if (idx >= size())
                {
                    throw std::out_of_range("array index " + std::to_string(idx) + " is out of range");
                }

                m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
            }
            else
            {
                throw std::domain_error("cannot use erase() with " + type_name());
            }
        }



        // lookup //


        iterator find(typename object_t::key_type key)
        {
            auto result = end();

            if (is_object())
            {
                result.m_it.object_iterator = m_value.object->find(key);
            }

            return result;
        }

        const_iterator find(typename object_t::key_type key) const
        {
            auto result = cend();

            if (is_object())
            {
                result.m_it.object_iterator = m_value.object->find(key);
            }

            return result;
        }

        size_type count(typename object_t::key_type key) const
        {
            // return 0 for all nonobject types
            return is_object() ? m_value.object->count(key) : 0;
        }



        // iterators //


        iterator begin() noexcept
        {
            iterator result(this);
            result.set_begin();
            return result;
        }

        const_iterator begin() const noexcept
        {
            return cbegin();
        }

        const_iterator cbegin() const noexcept
        {
            const_iterator result(this);
            result.set_begin();
            return result;
        }

        iterator end() noexcept
        {
            iterator result(this);
            result.set_end();
            return result;
        }

        const_iterator end() const noexcept
        {
            return cend();
        }

        const_iterator cend() const noexcept
        {
            const_iterator result(this);
            result.set_end();
            return result;
        }

        reverse_iterator rbegin() noexcept
        {
            return reverse_iterator(end());
        }

        const_reverse_iterator rbegin() const noexcept
        {
            return crbegin();
        }

        reverse_iterator rend() noexcept
        {
            return reverse_iterator(begin());
        }

        const_reverse_iterator rend() const noexcept
        {
            return crend();
        }

        const_reverse_iterator crbegin() const noexcept
        {
            return const_reverse_iterator(cend());
        }

        const_reverse_iterator crend() const noexcept
        {
            return const_reverse_iterator(cbegin());
        }

        private:
        // forward declaration
        template<typename IteratorType> class iteration_proxy;

        public:
        static iteration_proxy<iterator> iterator_wrapper(reference cont)
        {
            return iteration_proxy<iterator>(cont);
        }

        static iteration_proxy<const_iterator> iterator_wrapper(const_reference cont)
        {
            return iteration_proxy<const_iterator>(cont);
        }



        // capacity //


        bool empty() const noexcept
        {
            switch (m_type)
            {
                case value_t::null:
                {
                    // null values are empty
                    return true;
                }

                case value_t::array:
                {
                    // delegate call to array_t::empty()
                    return m_value.array->empty();
                }

                case value_t::object:
                {
                    // delegate call to object_t::empty()
                    return m_value.object->empty();
                }

                default:
                {
                    // all other types are nonempty
                    return false;
                }
            }
        }

        size_type size() const noexcept
        {
            switch (m_type)
            {
                case value_t::null:
                {
                    // null values are empty
                    return 0;
                }

                case value_t::array:
                {
                    // delegate call to array_t::size()
                    return m_value.array->size();
                }

                case value_t::object:
                {
                    // delegate call to object_t::size()
                    return m_value.object->size();
                }

                default:
                {
                    // all other types have size 1
                    return 1;
                }
            }
        }

        size_type max_size() const noexcept
        {
            switch (m_type)
            {
                case value_t::array:
                {
                    // delegate call to array_t::max_size()
                    return m_value.array->max_size();
                }

                case value_t::object:
                {
                    // delegate call to object_t::max_size()
                    return m_value.object->max_size();
                }

                default:
                {
                    // all other types have max_size() == size()
                    return size();
                }
            }
        }



        // modifiers //


        void clear() noexcept
        {
            switch (m_type)
            {
                case value_t::number_integer:
                {
                    m_value.number_integer = 0;
                    break;
                }

                case value_t::number_unsigned:
                {
                    m_value.number_unsigned = 0;
                    break;
                }

                case value_t::number_float:
                {
                    m_value.number_float = 0.0;
                    break;
                }

                case value_t::boolean:
                {
                    m_value.boolean = false;
                    break;
                }

                case value_t::string:
                {
                    m_value.string->clear();
                    break;
                }

                case value_t::array:
                {
                    m_value.array->clear();
                    break;
                }

                case value_t::object:
                {
                    m_value.object->clear();
                    break;
                }

                default:
                {
                    break;
                }
            }
        }

        void push_back(basic_json&& val)
        {
            // push_back only works for null objects or arrays
            if (not(is_null() or is_array()))
            {
                throw std::domain_error("cannot use push_back() with " + type_name());
            }

            // transform null object into an array
            if (is_null())
            {
                m_type = value_t::array;
                m_value = value_t::array;
                assert_invariant();
            }

            // add element to array (move semantics)
            m_value.array->push_back(std::move(val));
            // invalidate object
            val.m_type = value_t::null;
        }

        reference operator+=(basic_json&& val)
        {
            push_back(std::move(val));
            return *this;
        }

        void push_back(const basic_json& val)
        {
            // push_back only works for null objects or arrays
            if (not(is_null() or is_array()))
            {
                throw std::domain_error("cannot use push_back() with " + type_name());
            }

            // transform null object into an array
            if (is_null())
            {
                m_type = value_t::array;
                m_value = value_t::array;
                assert_invariant();
            }

            // add element to array
            m_value.array->push_back(val);
        }

        reference operator+=(const basic_json& val)
        {
            push_back(val);
            return *this;
        }

        void push_back(const typename object_t::value_type& val)
        {
            // push_back only works for null objects or objects
            if (not(is_null() or is_object()))
            {
                throw std::domain_error("cannot use push_back() with " + type_name());
            }

            // transform null object into an object
            if (is_null())
            {
                m_type = value_t::object;
                m_value = value_t::object;
                assert_invariant();
            }

            // add element to array
            m_value.object->insert(val);
        }

        reference operator+=(const typename object_t::value_type& val)
        {
            push_back(val);
            return *this;
        }

        void push_back(std::initializer_list<basic_json> init)
        {
            if (is_object() and init.size() == 2 and init.begin()->is_string())
            {
                const string_t key = *init.begin();
                push_back(typename object_t::value_type(key, *(init.begin() + 1)));
            }
            else
            {
                push_back(basic_json(init));
            }
        }

        reference operator+=(std::initializer_list<basic_json> init)
        {
            push_back(init);
            return *this;
        }

        iterator insert(const_iterator pos, const basic_json& val)
        {
            // insert only works for arrays
            if (is_array())
            {
                // check if iterator pos fits to this JSON value
                if (pos.m_object != this)
                {
                    throw std::domain_error("iterator does not fit current value");
                }

                // insert to array and return iterator
                iterator result(this);
                result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, val);
                return result;
            }
            else
            {
                throw std::domain_error("cannot use insert() with " + type_name());
            }
        }

        iterator insert(const_iterator pos, basic_json&& val)
        {
            return insert(pos, val);
        }

        iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
        {
            // insert only works for arrays
            if (is_array())
            {
                // check if iterator pos fits to this JSON value
                if (pos.m_object != this)
                {
                    throw std::domain_error("iterator does not fit current value");
                }

                // insert to array and return iterator
                iterator result(this);
                result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
                return result;
            }
            else
            {
                throw std::domain_error("cannot use insert() with " + type_name());
            }
        }

        iterator insert(const_iterator pos, const_iterator first, const_iterator last)
        {
            // insert only works for arrays
            if (not is_array())
            {
                throw std::domain_error("cannot use insert() with " + type_name());
            }

            // check if iterator pos fits to this JSON value
            if (pos.m_object != this)
            {
                throw std::domain_error("iterator does not fit current value");
            }

            // check if range iterators belong to the same JSON object
            if (first.m_object != last.m_object)
            {
                throw std::domain_error("iterators do not fit");
            }

            if (first.m_object == this or last.m_object == this)
            {
                throw std::domain_error("passed iterators may not belong to container");
            }

            // insert to array and return iterator
            iterator result(this);
            result.m_it.array_iterator = m_value.array->insert(
                    pos.m_it.array_iterator,
                    first.m_it.array_iterator,
                    last.m_it.array_iterator);
            return result;
        }

        iterator insert(const_iterator pos, std::initializer_list<basic_json> ilist)
        {
            // insert only works for arrays
            if (not is_array())
            {
                throw std::domain_error("cannot use insert() with " + type_name());
            }

            // check if iterator pos fits to this JSON value
            if (pos.m_object != this)
            {
                throw std::domain_error("iterator does not fit current value");
            }

            // insert to array and return iterator
            iterator result(this);
            result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, ilist);
            return result;
        }

        void swap(reference other) noexcept (
                std::is_nothrow_move_constructible<value_t>::value and
        std::is_nothrow_move_assignable<value_t>::value and
        std::is_nothrow_move_constructible<json_value>::value and
        std::is_nothrow_move_assignable<json_value>::value
        )
        {
            std::swap(m_type, other.m_type);
            std::swap(m_value, other.m_value);
            assert_invariant();
        }

        void swap(array_t& other)
        {
            // swap only works for arrays
            if (is_array())
            {
                std::swap(*(m_value.array), other);
            }
            else
            {
                throw std::domain_error("cannot use swap() with " + type_name());
            }
        }

        void swap(object_t& other)
        {
            // swap only works for objects
            if (is_object())
            {
                std::swap(*(m_value.object), other);
            }
            else
            {
                throw std::domain_error("cannot use swap() with " + type_name());
            }
        }

        void swap(string_t& other)
        {
            // swap only works for strings
            if (is_string())
            {
                std::swap(*(m_value.string), other);
            }
            else
            {
                throw std::domain_error("cannot use swap() with " + type_name());
            }
        }



        // lexicographical comparison operators //


        private:
        friend bool operator<(const value_t lhs, const value_t rhs) noexcept
        {
            static constexpr std::array<uint8_t, 8> order = {{
                                                                     0, // null
                                                                     3, // object
                                                                     4, // array
                                                                     5, // string
                                                                     1, // boolean
                                                                     2, // integer
                                                                     2, // unsigned
                                                                     2, // float
                                                             }
            };

            // discarded values are not comparable
            if (lhs == value_t::discarded or rhs == value_t::discarded)
            {
                return false;
            }

            return order[static_cast<std::size_t>(lhs)] < order[static_cast<std::size_t>(rhs)];
        }

        public:
        friend bool operator==(const_reference lhs, const_reference rhs) noexcept
        {
            const auto lhs_type = lhs.type();
            const auto rhs_type = rhs.type();

            if (lhs_type == rhs_type)
            {
                switch (lhs_type)
                {
                    case value_t::array:
                    {
                        return *lhs.m_value.array == *rhs.m_value.array;
                    }
                    case value_t::object:
                    {
                        return *lhs.m_value.object == *rhs.m_value.object;
                    }
                    case value_t::null:
                    {
                        return true;
                    }
                    case value_t::string:
                    {
                        return *lhs.m_value.string == *rhs.m_value.string;
                    }
                    case value_t::boolean:
                    {
                        return lhs.m_value.boolean == rhs.m_value.boolean;
                    }
                    case value_t::number_integer:
                    {
                        return lhs.m_value.number_integer == rhs.m_value.number_integer;
                    }
                    case value_t::number_unsigned:
                    {
                        return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
                    }
                    case value_t::number_float:
                    {
                        return lhs.m_value.number_float == rhs.m_value.number_float;
                    }
                    default:
                    {
                        return false;
                    }
                }
            }
            else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
            {
                return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
            }
            else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
            {
                return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
            }
            else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
            {
                return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
            }
            else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
            {
                return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
            }
            else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
            {
                return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
            }
            else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
            {
                return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
            }

            return false;
        }

        friend bool operator==(const_reference v, std::nullptr_t) noexcept
        {
            return v.is_null();
        }

        friend bool operator==(std::nullptr_t, const_reference v) noexcept
        {
            return v.is_null();
        }

        friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
        {
            return not (lhs == rhs);
        }

        friend bool operator!=(const_reference v, std::nullptr_t) noexcept
        {
            return not v.is_null();
        }

        friend bool operator!=(std::nullptr_t, const_reference v) noexcept
        {
            return not v.is_null();
        }

        friend bool operator<(const_reference lhs, const_reference rhs) noexcept
        {
            const auto lhs_type = lhs.type();
            const auto rhs_type = rhs.type();

            if (lhs_type == rhs_type)
            {
                switch (lhs_type)
                {
                    case value_t::array:
                    {
                        return *lhs.m_value.array < *rhs.m_value.array;
                    }
                    case value_t::object:
                    {
                        return *lhs.m_value.object < *rhs.m_value.object;
                    }
                    case value_t::null:
                    {
                        return false;
                    }
                    case value_t::string:
                    {
                        return *lhs.m_value.string < *rhs.m_value.string;
                    }
                    case value_t::boolean:
                    {
                        return lhs.m_value.boolean < rhs.m_value.boolean;
                    }
                    case value_t::number_integer:
                    {
                        return lhs.m_value.number_integer < rhs.m_value.number_integer;
                    }
                    case value_t::number_unsigned:
                    {
                        return lhs.m_value.number_unsigned < rhs.m_value.number_unsigned;
                    }
                    case value_t::number_float:
                    {
                        return lhs.m_value.number_float < rhs.m_value.number_float;
                    }
                    default:
                    {
                        return false;
                    }
                }
            }
            else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
            {
                return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
            }
            else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
            {
                return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
            }
            else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
            {
                return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
            }
            else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
            {
                return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
            }
            else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
            {
                return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
            }
            else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
            {
                return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
            }

            // We only reach this line if we cannot compare values. In that case,
            // we compare types. Note we have to call the operator explicitly,
            // because MSVC has problems otherwise.
            return operator<(lhs_type, rhs_type);
        }

        friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
        {
            return not (rhs < lhs);
        }

        friend bool operator>(const_reference lhs, const_reference rhs) noexcept
        {
            return not (lhs <= rhs);
        }

        friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
        {
            return not (lhs < rhs);
        }



        // serialization //


        friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
        {
            // read width member and use it as indentation parameter if nonzero
            const bool pretty_print = (o.width() > 0);
            const auto indentation = (pretty_print ? o.width() : 0);

            // reset width to 0 for subsequent calls to this stream
            o.width(0);

            // fix locale problems
            const auto old_locale = o.imbue(std::locale(std::locale(), new DecimalSeparator));
            // set precision

            // 6, 15 or 16 digits of precision allows round-trip IEEE 754
            // string->float->string, string->double->string or string->long
            // double->string; to be safe, we read this value from
            // std::numeric_limits<number_float_t>::digits10
            const auto old_precision = o.precision(std::numeric_limits<double>::digits10);

            // do the actual serialization
            j.dump(o, pretty_print, static_cast<unsigned int>(indentation));

            // reset locale and precision
            o.imbue(old_locale);
            o.precision(old_precision);
            return o;
        }

        friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
        {
            return o << j;
        }



        // deserialization //


        template<class T, std::size_t N>
        static basic_json parse(T (&array)[N],
        const parser_callback_t cb = nullptr)
        {
            // delegate the call to the iterator-range parse overload
            return parse(std::begin(array), std::end(array), cb);
        }

        template<typename CharPT, typename std::enable_if<
                                           std::is_pointer<CharPT>::value and
        std::is_integral<typename std::remove_pointer<CharPT>::type>::value and
        sizeof(typename std::remove_pointer<CharPT>::type) == 1, int>::type = 0>
        static basic_json parse(const CharPT s,
        const parser_callback_t cb = nullptr)
        {
            return parser(reinterpret_cast<const char*>(s), cb).parse();
        }

        static basic_json parse(std::istream& i,
        const parser_callback_t cb = nullptr)
        {
            return parser(i, cb).parse();
        }

        static basic_json parse(std::istream&& i,
        const parser_callback_t cb = nullptr)
        {
            return parser(i, cb).parse();
        }

        template<class IteratorType, typename std::enable_if<
                                              std::is_base_of<
                                              std::random_access_iterator_tag,
                typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
        static basic_json parse(IteratorType first, IteratorType last,
        const parser_callback_t cb = nullptr)
        {
            // assertion to check that the iterator range is indeed contiguous,
            // see http://stackoverflow.com/a/35008842/266378 for more discussion
            assert(std::accumulate(first, last, std::make_pair<bool, int>(true, 0),
                   [&first](std::pair<bool, int> res, decltype(*first) val)
            {
                res.first &= (val == *(std::next(std::addressof(*first), res.second++)));
                return res;
            }).first);

            // assertion to check that each element is 1 byte long
            static_assert(sizeof(typename std::iterator_traits<IteratorType>::value_type) == 1,
                    "each element in the iterator range must have the size of 1 byte");

            // if iterator range is empty, create a parser with an empty string
            // to generate "unexpected EOF" error message
            if (std::distance(first, last) <= 0)
            {
                return parser("").parse();
            }

            return parser(first, last, cb).parse();
        }

        template<class ContiguousContainer, typename std::enable_if<
                                                     not std::is_pointer<ContiguousContainer>::value and
        std::is_base_of<
        std::random_access_iterator_tag,
                typename std::iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value
                , int>::type = 0>
        static basic_json parse(const ContiguousContainer& c,
        const parser_callback_t cb = nullptr)
        {
            // delegate the call to the iterator-range parse overload
            return parse(std::begin(c), std::end(c), cb);
        }

        friend std::istream& operator<<(basic_json& j, std::istream& i)
        {
            j = parser(i).parse();
            return i;
        }

        friend std::istream& operator>>(std::istream& i, basic_json& j)
        {
            j = parser(i).parse();
            return i;
        }



        private:
        // convenience functions //

        std::string type_name() const
        {
            switch (m_type)
            {
                case value_t::null:
                    return "null";
                case value_t::object:
                    return "object";
                case value_t::array:
                    return "array";
                case value_t::string:
                    return "string";
                case value_t::boolean:
                    return "boolean";
                case value_t::discarded:
                    return "discarded";
                default:
                    return "number";
            }
        }

        static std::size_t extra_space(const string_t& s) noexcept
        {
            return std::accumulate(s.begin(), s.end(), size_t{},
            [](size_t res, typename string_t::value_type c)
            {
                switch (c)
                {
                    case '"':
                    case '\\':
                    case '\b':
                    case '\f':
                    case '\n':
                    case '\r':
                    case '\t':
                    {
                        // from c (1 byte) to \x (2 bytes)
                        return res + 1;
                    }

                    default:
                    {
                        if (c >= 0x00 and c <= 0x1f)
                        {
                            // from c (1 byte) to \uxxxx (6 bytes)
                            return res + 5;
                        }
                        else
                        {
                            return res;
                        }
                    }
                }
            });
        }

        static string_t escape_string(const string_t& s)
        {
            const auto space = extra_space(s);
            if (space == 0)
            {
                return s;
            }

            // create a result string of necessary size
            string_t result(s.size() + space, '\\');
            std::size_t pos = 0;

            for (const auto& c : s)
            {
                switch (c)
                {
                    // quotation mark (0x22)
                    case '"':
                    {
                        result[pos + 1] = '"';
                        pos += 2;
                        break;
                    }

                        // reverse solidus (0x5c)
                    case '\\':
                    {
                        // nothing to change
                        pos += 2;
                        break;
                    }

                        // backspace (0x08)
                    case '\b':
                    {
                        result[pos + 1] = 'b';
                        pos += 2;
                        break;
                    }

                        // formfeed (0x0c)
                    case '\f':
                    {
                        result[pos + 1] = 'f';
                        pos += 2;
                        break;
                    }

                        // newline (0x0a)
                    case '\n':
                    {
                        result[pos + 1] = 'n';
                        pos += 2;
                        break;
                    }

                        // carriage return (0x0d)
                    case '\r':
                    {
                        result[pos + 1] = 'r';
                        pos += 2;
                        break;
                    }

                        // horizontal tab (0x09)
                    case '\t':
                    {
                        result[pos + 1] = 't';
                        pos += 2;
                        break;
                    }

                    default:
                    {
                        if (c >= 0x00 and c <= 0x1f)
                        {
                            // convert a number 0..15 to its hex representation
                            // (0..f)
                            static const char hexify[16] =
                                    {
                                            '0', '1', '2', '3', '4', '5', '6', '7',
                                            '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
                                    };

                            // print character c as \uxxxx
                            for (const char m :
                                    { 'u', '0', '0', hexify[c >> 4], hexify[c & 0x0f]
                                    })
                            {
                                result[++pos] = m;
                            }

                            ++pos;
                        }
                        else
                        {
                            // all other characters are added as-is
                            result[pos++] = c;
                        }
                        break;
                    }
                }
            }

            return result;
        }

        void dump(std::ostream& o,
        const bool pretty_print,
        const unsigned int indent_step,
        const unsigned int current_indent = 0) const
        {
            // variable to hold indentation for recursive calls
            unsigned int new_indent = current_indent;

            switch (m_type)
            {
                case value_t::object:
                {
                    if (m_value.object->empty())
                    {
                        o << "{}";
                        return;
                    }

                    o << "{";

                    // increase indentation
                    if (pretty_print)
                    {
                        new_indent += indent_step;
                        o << "\n";
                    }

                    for (auto i = m_value.object->cbegin(); i != m_value.object->cend(); ++i)
                    {
                        if (i != m_value.object->cbegin())
                        {
                            o << (pretty_print ? ",\n" : ",");
                        }
                        o << string_t(new_indent, ' ') << "\""
                          << escape_string(i->first) << "\":"
                          << (pretty_print ? " " : "");
                        i->second.dump(o, pretty_print, indent_step, new_indent);
                    }

                    // decrease indentation
                    if (pretty_print)
                    {
                        new_indent -= indent_step;
                        o << "\n";
                    }

                    o << string_t(new_indent, ' ') + "}";
                    return;
                }

                case value_t::array:
                {
                    if (m_value.array->empty())
                    {
                        o << "[]";
                        return;
                    }

                    o << "[";

                    // increase indentation
                    if (pretty_print)
                    {
                        new_indent += indent_step;
                        o << "\n";
                    }

                    for (auto i = m_value.array->cbegin(); i != m_value.array->cend(); ++i)
                    {
                        if (i != m_value.array->cbegin())
                        {
                            o << (pretty_print ? ",\n" : ",");
                        }
                        o << string_t(new_indent, ' ');
                        i->dump(o, pretty_print, indent_step, new_indent);
                    }

                    // decrease indentation
                    if (pretty_print)
                    {
                        new_indent -= indent_step;
                        o << "\n";
                    }

                    o << string_t(new_indent, ' ') << "]";
                    return;
                }

                case value_t::string:
                {
                    o << string_t("\"") << escape_string(*m_value.string) << "\"";
                    return;
                }

                case value_t::boolean:
                {
                    o << (m_value.boolean ? "true" : "false");
                    return;
                }

                case value_t::number_integer:
                {
                    o << m_value.number_integer;
                    return;
                }

                case value_t::number_unsigned:
                {
                    o << m_value.number_unsigned;
                    return;
                }

                case value_t::number_float:
                {
                    if (m_value.number_float == 0)
                    {
                        // special case for zero to get "0.0"/"-0.0"
                        o << (std::signbit(m_value.number_float) ? "-0.0" : "0.0");
                    }
                    else
                    {
                        o << m_value.number_float;
                    }
                    return;
                }

                case value_t::discarded:
                {
                    o << "<discarded>";
                    return;
                }

                case value_t::null:
                {
                    o << "null";
                    return;
                }
            }
        }

        private:
        // member variables //

        value_t m_type = value_t::null;

        json_value m_value = {};


        private:
        // iterators //

        class primitive_iterator_t
        {
            public:
            void set_begin() noexcept
            {
                m_it = begin_value;
            }

            void set_end() noexcept
            {
                m_it = end_value;
            }

            constexpr bool is_begin() const noexcept
            {
                return (m_it == begin_value);
            }

            constexpr bool is_end() const noexcept
            {
                return (m_it == end_value);
            }

            operator difference_type& () noexcept
            {
                return m_it;
            }

            constexpr operator difference_type () const noexcept
            {
                return m_it;
            }

            private:
            static constexpr difference_type begin_value = 0;
            static constexpr difference_type end_value = begin_value + 1;

            difference_type m_it = std::numeric_limits<std::ptrdiff_t>::denorm_min();
        };

        struct internal_iterator
        {
            typename object_t::iterator object_iterator;
            typename array_t::iterator array_iterator;
            primitive_iterator_t primitive_iterator;

            internal_iterator() noexcept
                    : object_iterator(), array_iterator(), primitive_iterator()
            {}
        };

        template<typename IteratorType>
                          class iteration_proxy
        {
            private:
            class iteration_proxy_internal
            {
                private:
                IteratorType anchor;
                size_t array_index = 0;

                public:
                explicit iteration_proxy_internal(IteratorType it) noexcept
                : anchor(it)
                {}

                iteration_proxy_internal& operator*()
                {
                    return *this;
                }

                iteration_proxy_internal& operator++()
                {
                    ++anchor;
                    ++array_index;

                    return *this;
                }

                bool operator!= (const iteration_proxy_internal& o) const
                {
                    return anchor != o.anchor;
                }

                typename basic_json::string_t key() const
                {
                    assert(anchor.m_object != nullptr);

                    switch (anchor.m_object->type())
                    {
                        // use integer array index as key
                        case value_t::array:
                        {
                            return std::to_string(array_index);
                        }

                            // use key from the object
                        case value_t::object:
                        {
                            return anchor.key();
                        }

                            // use an empty key for all primitive types
                        default:
                        {
                            return "";
                        }
                    }
                }

                typename IteratorType::reference value() const
                {
                    return anchor.value();
                }
            };

            typename IteratorType::reference container;

            public:
            explicit iteration_proxy(typename IteratorType::reference cont)
            : container(cont)
            {}

            iteration_proxy_internal begin() noexcept
            {
                return iteration_proxy_internal(container.begin());
            }

            iteration_proxy_internal end() noexcept
            {
                return iteration_proxy_internal(container.end());
            }
        };

        public:
        class const_iterator : public std::iterator<std::random_access_iterator_tag, const basic_json>
        {
            friend class basic_json;

            public:
            using value_type = typename basic_json::value_type;
            using difference_type = typename basic_json::difference_type;
            using pointer = typename basic_json::const_pointer;
            using reference = typename basic_json::const_reference;
            using iterator_category = std::bidirectional_iterator_tag;

            const_iterator() = default;

            explicit const_iterator(pointer object) noexcept
            : m_object(object)
            {
                assert(m_object != nullptr);

                switch (m_object->m_type)
                {
                    case basic_json::value_t::object:
                    {
                        m_it.object_iterator = typename object_t::iterator();
                        break;
                    }

                    case basic_json::value_t::array:
                    {
                        m_it.array_iterator = typename array_t::iterator();
                        break;
                    }

                    default:
                    {
                        m_it.primitive_iterator = primitive_iterator_t();
                        break;
                    }
                }
            }

            explicit const_iterator(const iterator& other) noexcept
            : m_object(other.m_object)
            {
                if (m_object != nullptr)
                {
                    switch (m_object->m_type)
                    {
                        case basic_json::value_t::object:
                        {
                            m_it.object_iterator = other.m_it.object_iterator;
                            break;
                        }

                        case basic_json::value_t::array:
                        {
                            m_it.array_iterator = other.m_it.array_iterator;
                            break;
                        }

                        default:
                        {
                            m_it.primitive_iterator = other.m_it.primitive_iterator;
                            break;
                        }
                    }
                }
            }

            const_iterator(const const_iterator& other) noexcept
            : m_object(other.m_object), m_it(other.m_it)
            {}

            const_iterator& operator=(const_iterator other) noexcept(
                    std::is_nothrow_move_constructible<pointer>::value and
            std::is_nothrow_move_assignable<pointer>::value and
            std::is_nothrow_move_constructible<internal_iterator>::value and
            std::is_nothrow_move_assignable<internal_iterator>::value
            )
            {
                std::swap(m_object, other.m_object);
                std::swap(m_it, other.m_it);
                return *this;
            }

            private:
            void set_begin() noexcept
            {
                assert(m_object != nullptr);

                switch (m_object->m_type)
                {
                    case basic_json::value_t::object:
                    {
                        m_it.object_iterator = m_object->m_value.object->begin();
                        break;
                    }

                    case basic_json::value_t::array:
                    {
                        m_it.array_iterator = m_object->m_value.array->begin();
                        break;
                    }

                    case basic_json::value_t::null:
                    {
                        // set to end so begin()==end() is true: null is empty
                        m_it.primitive_iterator.set_end();
                        break;
                    }

                    default:
                    {
                        m_it.primitive_iterator.set_begin();
                        break;
                    }
                }
            }

            void set_end() noexcept
            {
                assert(m_object != nullptr);

                switch (m_object->m_type)
                {
                    case basic_json::value_t::object:
                    {
                        m_it.object_iterator = m_object->m_value.object->end();
                        break;
                    }

                    case basic_json::value_t::array:
                    {
                        m_it.array_iterator = m_object->m_value.array->end();
                        break;
                    }

                    default:
                    {
                        m_it.primitive_iterator.set_end();
                        break;
                    }
                }
            }

            public:
            reference operator*() const
            {
                assert(m_object != nullptr);

                switch (m_object->m_type)
                {
                    case basic_json::value_t::object:
                    {
                        assert(m_it.object_iterator != m_object->m_value.object->end());
                        return m_it.object_iterator->second;
                    }

                    case basic_json::value_t::array:
                    {
                        assert(m_it.array_iterator != m_object->m_value.array->end());
                        return *m_it.array_iterator;
                    }

                    case basic_json::value_t::null:
                    {
                        throw std::out_of_range("cannot get value");
                    }

                    default:
                    {
                        if (m_it.primitive_iterator.is_begin())
                        {
                            return *m_object;
                        }
                        else
                        {
                            throw std::out_of_range("cannot get value");
                        }
                    }
                }
            }

            pointer operator->() const
            {
                assert(m_object != nullptr);

                switch (m_object->m_type)
                {
                    case basic_json::value_t::object:
                    {
                        assert(m_it.object_iterator != m_object->m_value.object->end());
                        return &(m_it.object_iterator->second);
                    }

                    case basic_json::value_t::array:
                    {
                        assert(m_it.array_iterator != m_object->m_value.array->end());
                        return &*m_it.array_iterator;
                    }

                    default:
                    {
                        if (m_it.primitive_iterator.is_begin())
                        {
                            return m_object;
                        }
                        else
                        {
                            throw std::out_of_range("cannot get value");
                        }
                    }
                }
            }

            const_iterator operator++(int)
            {
                auto result = *this;
                ++(*this);
                return result;
            }

            const_iterator& operator++()
            {
                assert(m_object != nullptr);

                switch (m_object->m_type)
                {
                    case basic_json::value_t::object:
                    {
                        std::advance(m_it.object_iterator, 1);
                        break;
                    }

                    case basic_json::value_t::array:
                    {
                        std::advance(m_it.array_iterator, 1);
                        break;
                    }

                    default:
                    {
                        ++m_it.primitive_iterator;
                        break;
                    }
                }

                return *this;
            }

            const_iterator operator--(int)
            {
                auto result = *this;
                --(*this);
                return result;
            }

            const_iterator& operator--()
            {
                assert(m_object != nullptr);

                switch (m_object->m_type)
                {
                    case basic_json::value_t::object:
                    {
                        std::advance(m_it.object_iterator, -1);
                        break;
                    }

                    case basic_json::value_t::array:
                    {
                        std::advance(m_it.array_iterator, -1);
                        break;
                    }

                    default:
                    {
                        --m_it.primitive_iterator;
                        break;
                    }
                }

                return *this;
            }

            bool operator==(const const_iterator& other) const
            {
                // if objects are not the same, the comparison is undefined
                if (m_object != other.m_object)
                {
                    throw std::domain_error("cannot compare iterators of different containers");
                }

                assert(m_object != nullptr);

                switch (m_object->m_type)
                {
                    case basic_json::value_t::object:
                    {
                        return (m_it.object_iterator == other.m_it.object_iterator);
                    }

                    case basic_json::value_t::array:
                    {
                        return (m_it.array_iterator == other.m_it.array_iterator);
                    }

                    default:
                    {
                        return (m_it.primitive_iterator == other.m_it.primitive_iterator);
                    }
                }
            }

            bool operator!=(const const_iterator& other) const
            {
                return not operator==(other);
            }

            bool operator<(const const_iterator& other) const
            {
                // if objects are not the same, the comparison is undefined
                if (m_object != other.m_object)
                {
                    throw std::domain_error("cannot compare iterators of different containers");
                }

                assert(m_object != nullptr);

                switch (m_object->m_type)
                {
                    case basic_json::value_t::object:
                    {
                        throw std::domain_error("cannot compare order of object iterators");
                    }

                    case basic_json::value_t::array:
                    {
                        return (m_it.array_iterator < other.m_it.array_iterator);
                    }

                    default:
                    {
                        return (m_it.primitive_iterator < other.m_it.primitive_iterator);
                    }
                }
            }

            bool operator<=(const const_iterator& other) const
            {
                return not other.operator < (*this);
            }

            bool operator>(const const_iterator& other) const
            {
                return not operator<=(other);
            }

            bool operator>=(const const_iterator& other) const
            {
                return not operator<(other);
            }

            const_iterator& operator+=(difference_type i)
            {
                assert(m_object != nullptr);

                switch (m_object->m_type)
                {
                    case basic_json::value_t::object:
                    {
                        throw std::domain_error("cannot use offsets with object iterators");
                    }

                    case basic_json::value_t::array:
                    {
                        std::advance(m_it.array_iterator, i);
                        break;
                    }

                    default:
                    {
                        m_it.primitive_iterator += i;
                        break;
                    }
                }

                return *this;
            }

            const_iterator& operator-=(difference_type i)
            {
                return operator+=(-i);
            }

            const_iterator operator+(difference_type i)
            {
                auto result = *this;
                result += i;
                return result;
            }

            const_iterator operator-(difference_type i)
            {
                auto result = *this;
                result -= i;
                return result;
            }

            difference_type operator-(const const_iterator& other) const
            {
                assert(m_object != nullptr);

                switch (m_object->m_type)
                {
                    case basic_json::value_t::object:
                    {
                        throw std::domain_error("cannot use offsets with object iterators");
                    }

                    case basic_json::value_t::array:
                    {
                        return m_it.array_iterator - other.m_it.array_iterator;
                    }

                    default:
                    {
                        return m_it.primitive_iterator - other.m_it.primitive_iterator;
                    }
                }
            }

            reference operator[](difference_type n) const
            {
                assert(m_object != nullptr);

                switch (m_object->m_type)
                {
                    case basic_json::value_t::object:
                    {
                        throw std::domain_error("cannot use operator[] for object iterators");
                    }

                    case basic_json::value_t::array:
                    {
                        return *std::next(m_it.array_iterator, n);
                    }

                    case basic_json::value_t::null:
                    {
                        throw std::out_of_range("cannot get value");
                    }

                    default:
                    {
                        if (m_it.primitive_iterator == -n)
                        {
                            return *m_object;
                        }
                        else
                        {
                            throw std::out_of_range("cannot get value");
                        }
                    }
                }
            }

            typename object_t::key_type key() const
            {
                assert(m_object != nullptr);

                if (m_object->is_object())
                {
                    return m_it.object_iterator->first;
                }
                else
                {
                    throw std::domain_error("cannot use key() for non-object iterators");
                }
            }

            reference value() const
            {
                return operator*();
            }

            private:
            pointer m_object = nullptr;
            internal_iterator m_it = internal_iterator();
        };

        class iterator : public const_iterator
        {
            public:
            using base_iterator = const_iterator;
            using pointer = typename basic_json::pointer;
            using reference = typename basic_json::reference;

            iterator() = default;

            explicit iterator(pointer object) noexcept
            : base_iterator(object)
            {}

            iterator(const iterator& other) noexcept
            : base_iterator(other)
            {}

            iterator& operator=(iterator other) noexcept(
                    std::is_nothrow_move_constructible<pointer>::value and
            std::is_nothrow_move_assignable<pointer>::value and
            std::is_nothrow_move_constructible<internal_iterator>::value and
            std::is_nothrow_move_assignable<internal_iterator>::value
            )
            {
                base_iterator::operator=(other);
                return *this;
            }

            reference operator*() const
            {
                return const_cast<reference>(base_iterator::operator*());
            }

            pointer operator->() const
            {
                return const_cast<pointer>(base_iterator::operator->());
            }

            iterator operator++(int)
            {
                iterator result = *this;
                base_iterator::operator++();
                return result;
            }

            iterator& operator++()
            {
                base_iterator::operator++();
                return *this;
            }

            iterator operator--(int)
            {
                iterator result = *this;
                base_iterator::operator--();
                return result;
            }

            iterator& operator--()
            {
                base_iterator::operator--();
                return *this;
            }

            iterator& operator+=(difference_type i)
            {
                base_iterator::operator+=(i);
                return *this;
            }

            iterator& operator-=(difference_type i)
            {
                base_iterator::operator-=(i);
                return *this;
            }

            iterator operator+(difference_type i)
            {
                auto result = *this;
                result += i;
                return result;
            }

            iterator operator-(difference_type i)
            {
                auto result = *this;
                result -= i;
                return result;
            }

            difference_type operator-(const iterator& other) const
            {
                return base_iterator::operator-(other);
            }

            reference operator[](difference_type n) const
            {
                return const_cast<reference>(base_iterator::operator[](n));
            }

            reference value() const
            {
                return const_cast<reference>(base_iterator::value());
            }
        };

        template<typename Base>
                          class json_reverse_iterator : public std::reverse_iterator<Base>
    {
        public:
        using base_iterator = std::reverse_iterator<Base>;
        using reference = typename Base::reference;

        json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
        : base_iterator(it)
        {}

        json_reverse_iterator(const base_iterator& it) noexcept
        : base_iterator(it)
        {}

        json_reverse_iterator operator++(int)
        {
            return base_iterator::operator++(1);
        }

        json_reverse_iterator& operator++()
        {
            base_iterator::operator++();
            return *this;
        }

        json_reverse_iterator operator--(int)
        {
            return base_iterator::operator--(1);
        }

        json_reverse_iterator& operator--()
        {
            base_iterator::operator--();
            return *this;
        }

        json_reverse_iterator& operator+=(difference_type i)
        {
            base_iterator::operator+=(i);
            return *this;
        }

        json_reverse_iterator operator+(difference_type i) const
        {
            auto result = *this;
            result += i;
            return result;
        }

        json_reverse_iterator operator-(difference_type i) const
        {
            auto result = *this;
            result -= i;
            return result;
        }

        difference_type operator-(const json_reverse_iterator& other) const
        {
            return this->base() - other.base();
        }

        reference operator[](difference_type n) const
        {
            return *(this->operator+(n));
        }

        typename object_t::key_type key() const
        {
            auto it = --this->base();
            return it.key();
        }

        reference value() const
        {
            auto it = --this->base();
            return it.operator * ();
        }
    };


        private:
        // lexer and parser //

        class lexer
        {
            public:
            enum class token_type
            {
                uninitialized,   
                        literal_true,    
                        literal_false,   
                        literal_null,    
                        value_string,    
                        value_number,    
                        begin_array,     
                        begin_object,    
                        end_array,       
                        end_object,      
                        name_separator,  
                        value_separator, 
                        parse_error,     
                        end_of_input     
            };

            using lexer_char_t = unsigned char;

            lexer(const lexer_char_t* buff, const size_t len) noexcept
            : m_content(buff)
            {
                assert(m_content != nullptr);
                m_start = m_cursor = m_content;
                m_limit = m_content + len;
            }

            explicit lexer(std::istream& s)
            : m_stream(&s), m_line_buffer()
            {
                // fill buffer
                fill_line_buffer();
            }

            // switch off unwanted functions (due to pointer members)
            lexer() = delete;
            lexer(const lexer&) = delete;
            lexer operator=(const lexer&) = delete;

            static string_t to_unicode(const std::size_t codepoint1,
            const std::size_t codepoint2 = 0)
            {
                // calculate the code point from the given code points
                std::size_t codepoint = codepoint1;

                // check if codepoint1 is a high surrogate
                if (codepoint1 >= 0xD800 and codepoint1 <= 0xDBFF)
                {
                    // check if codepoint2 is a low surrogate
                    if (codepoint2 >= 0xDC00 and codepoint2 <= 0xDFFF)
                    {
                        codepoint =
                                // high surrogate occupies the most significant 22 bits
                                (codepoint1 << 10)
                                // low surrogate occupies the least significant 15 bits
                                + codepoint2
                                // there is still the 0xD800, 0xDC00 and 0x10000 noise
                                // in the result so we have to subtract with:
                                // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
                                - 0x35FDC00;
                    }
                    else
                    {
                        throw std::invalid_argument("missing or wrong low surrogate");
                    }
                }

                string_t result;

                if (codepoint < 0x80)
                {
                    // 1-byte characters: 0xxxxxxx (ASCII)
                    result.append(1, static_cast<typename string_t::value_type>(codepoint));
                }
                else if (codepoint <= 0x7ff)
                {
                    // 2-byte characters: 110xxxxx 10xxxxxx
                    result.append(1, static_cast<typename string_t::value_type>(0xC0 | ((codepoint >> 6) & 0x1F)));
                    result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
                }
                else if (codepoint <= 0xffff)
                {
                    // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
                    result.append(1, static_cast<typename string_t::value_type>(0xE0 | ((codepoint >> 12) & 0x0F)));
                    result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
                    result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
                }
                else if (codepoint <= 0x10ffff)
                {
                    // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
                    result.append(1, static_cast<typename string_t::value_type>(0xF0 | ((codepoint >> 18) & 0x07)));
                    result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 12) & 0x3F)));
                    result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
                    result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
                }
                else
                {
                    throw std::out_of_range("code points above 0x10FFFF are invalid");
                }

                return result;
            }

            static std::string token_type_name(const token_type t)
            {
                switch (t)
                {
                    case token_type::uninitialized:
                        return "<uninitialized>";
                    case token_type::literal_true:
                        return "true literal";
                    case token_type::literal_false:
                        return "false literal";
                    case token_type::literal_null:
                        return "null literal";
                    case token_type::value_string:
                        return "string literal";
                    case token_type::value_number:
                        return "number literal";
                    case token_type::begin_array:
                        return "'['";
                    case token_type::begin_object:
                        return "'{'";
                    case token_type::end_array:
                        return "']'";
                    case token_type::end_object:
                        return "'}'";
                    case token_type::name_separator:
                        return "':'";
                    case token_type::value_separator:
                        return "','";
                    case token_type::parse_error:
                        return "<parse error>";
                    case token_type::end_of_input:
                        return "end of input";
                    default:
                    {
                        // catch non-enum values
                        return "unknown token"; // LCOV_EXCL_LINE
                    }
                }
            }

            token_type scan()
            {
                while (true)
                {
                    // pointer for backtracking information
                    m_marker = nullptr;

                    // remember the begin of the token
                    m_start = m_cursor;
                    assert(m_start != nullptr);


                    {
                        lexer_char_t yych;
                        unsigned int yyaccept = 0;
                        static const unsigned char yybm[] =
                                {
                                        0,   0,   0,   0,   0,   0,   0,   0,
                                        0,  32,  32,   0,   0,  32,   0,   0,
                                        0,   0,   0,   0,   0,   0,   0,   0,
                                        0,   0,   0,   0,   0,   0,   0,   0,
                                        160, 128,   0, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        192, 192, 192, 192, 192, 192, 192, 192,
                                        192, 192, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128,   0, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                        128, 128, 128, 128, 128, 128, 128, 128,
                                };
                        if ((m_limit - m_cursor) < 5)
                        {
                            fill_line_buffer();
                        }
                        yych = *m_cursor;
                        if (yybm[0 + yych] & 32)
                        {
                            goto basic_json_parser_6;
                        }
                        if (yych <= '\\')
                        {
                            if (yych <= '-')
                            {
                                if (yych <= '"')
                                {
                                    if (yych <= 0x00)
                                    {
                                        goto basic_json_parser_2;
                                    }
                                    if (yych <= '!')
                                    {
                                        goto basic_json_parser_4;
                                    }
                                    goto basic_json_parser_9;
                                }
                                else
                                {
                                    if (yych <= '+')
                                    {
                                        goto basic_json_parser_4;
                                    }
                                    if (yych <= ',')
                                    {
                                        goto basic_json_parser_10;
                                    }
                                    goto basic_json_parser_12;
                                }
                            }
                            else
                            {
                                if (yych <= '9')
                                {
                                    if (yych <= '/')
                                    {
                                        goto basic_json_parser_4;
                                    }
                                    if (yych <= '0')
                                    {
                                        goto basic_json_parser_13;
                                    }
                                    goto basic_json_parser_15;
                                }
                                else
                                {
                                    if (yych <= ':')
                                    {
                                        goto basic_json_parser_17;
                                    }
                                    if (yych == '[')
                                    {
                                        goto basic_json_parser_19;
                                    }
                                    goto basic_json_parser_4;
                                }
                            }
                        }
                        else
                        {
                            if (yych <= 't')
                            {
                                if (yych <= 'f')
                                {
                                    if (yych <= ']')
                                    {
                                        goto basic_json_parser_21;
                                    }
                                    if (yych <= 'e')
                                    {
                                        goto basic_json_parser_4;
                                    }
                                    goto basic_json_parser_23;
                                }
                                else
                                {
                                    if (yych == 'n')
                                    {
                                        goto basic_json_parser_24;
                                    }
                                    if (yych <= 's')
                                    {
                                        goto basic_json_parser_4;
                                    }
                                    goto basic_json_parser_25;
                                }
                            }
                            else
                            {
                                if (yych <= '|')
                                {
                                    if (yych == '{')
                                    {
                                        goto basic_json_parser_26;
                                    }
                                    goto basic_json_parser_4;
                                }
                                else
                                {
                                    if (yych <= '}')
                                    {
                                        goto basic_json_parser_28;
                                    }
                                    if (yych == 0xEF)
                                    {
                                        goto basic_json_parser_30;
                                    }
                                    goto basic_json_parser_4;
                                }
                            }
                        }
                        basic_json_parser_2:
                        ++m_cursor;
                        {
                            last_token_type = token_type::end_of_input;
                            break;
                        }
                        basic_json_parser_4:
                        ++m_cursor;
                        basic_json_parser_5:
                        {
                            last_token_type = token_type::parse_error;
                            break;
                        }
                        basic_json_parser_6:
                        ++m_cursor;
                        if (m_limit <= m_cursor)
                        {
                            fill_line_buffer();
                        }
                        yych = *m_cursor;
                        if (yybm[0 + yych] & 32)
                        {
                            goto basic_json_parser_6;
                        }
                        {
                            continue;
                        }
                        basic_json_parser_9:
                        yyaccept = 0;
                        yych = *(m_marker = ++m_cursor);
                        if (yych <= 0x1F)
                        {
                            goto basic_json_parser_5;
                        }
                        goto basic_json_parser_32;
                        basic_json_parser_10:
                        ++m_cursor;
                        {
                            last_token_type = token_type::value_separator;
                            break;
                        }
                        basic_json_parser_12:
                        yych = *++m_cursor;
                        if (yych <= '/')
                        {
                            goto basic_json_parser_5;
                        }
                        if (yych <= '0')
                        {
                            goto basic_json_parser_13;
                        }
                        if (yych <= '9')
                        {
                            goto basic_json_parser_15;
                        }
                        goto basic_json_parser_5;
                        basic_json_parser_13:
                        yyaccept = 1;
                        yych = *(m_marker = ++m_cursor);
                        if (yych <= 'D')
                        {
                            if (yych == '.')
                            {
                                goto basic_json_parser_37;
                            }
                        }
                        else
                        {
                            if (yych <= 'E')
                            {
                                goto basic_json_parser_38;
                            }
                            if (yych == 'e')
                            {
                                goto basic_json_parser_38;
                            }
                        }
                        basic_json_parser_14:
                        {
                            last_token_type = token_type::value_number;
                            break;
                        }
                        basic_json_parser_15:
                        yyaccept = 1;
                        m_marker = ++m_cursor;
                        if ((m_limit - m_cursor) < 3)
                        {
                            fill_line_buffer();
                        }
                        yych = *m_cursor;
                        if (yybm[0 + yych] & 64)
                        {
                            goto basic_json_parser_15;
                        }
                        if (yych <= 'D')
                        {
                            if (yych == '.')
                            {
                                goto basic_json_parser_37;
                            }
                            goto basic_json_parser_14;
                        }
                        else
                        {
                            if (yych <= 'E')
                            {
                                goto basic_json_parser_38;
                            }
                            if (yych == 'e')
                            {
                                goto basic_json_parser_38;
                            }
                            goto basic_json_parser_14;
                        }
                        basic_json_parser_17:
                        ++m_cursor;
                        {
                            last_token_type = token_type::name_separator;
                            break;
                        }
                        basic_json_parser_19:
                        ++m_cursor;
                        {
                            last_token_type = token_type::begin_array;
                            break;
                        }
                        basic_json_parser_21:
                        ++m_cursor;
                        {
                            last_token_type = token_type::end_array;
                            break;
                        }
                        basic_json_parser_23:
                        yyaccept = 0;
                        yych = *(m_marker = ++m_cursor);
                        if (yych == 'a')
                        {
                            goto basic_json_parser_39;
                        }
                        goto basic_json_parser_5;
                        basic_json_parser_24:
                        yyaccept = 0;
                        yych = *(m_marker = ++m_cursor);
                        if (yych == 'u')
                        {
                            goto basic_json_parser_40;
                        }
                        goto basic_json_parser_5;
                        basic_json_parser_25:
                        yyaccept = 0;
                        yych = *(m_marker = ++m_cursor);
                        if (yych == 'r')
                        {
                            goto basic_json_parser_41;
                        }
                        goto basic_json_parser_5;
                        basic_json_parser_26:
                        ++m_cursor;
                        {
                            last_token_type = token_type::begin_object;
                            break;
                        }
                        basic_json_parser_28:
                        ++m_cursor;
                        {
                            last_token_type = token_type::end_object;
                            break;
                        }
                        basic_json_parser_30:
                        yyaccept = 0;
                        yych = *(m_marker = ++m_cursor);
                        if (yych == 0xBB)
                        {
                            goto basic_json_parser_42;
                        }
                        goto basic_json_parser_5;
                        basic_json_parser_31:
                        ++m_cursor;
                        if (m_limit <= m_cursor)
                        {
                            fill_line_buffer();
                        }
                        yych = *m_cursor;
                        basic_json_parser_32:
                        if (yybm[0 + yych] & 128)
                        {
                            goto basic_json_parser_31;
                        }
                        if (yych <= 0x1F)
                        {
                            goto basic_json_parser_33;
                        }
                        if (yych <= '"')
                        {
                            goto basic_json_parser_34;
                        }
                        goto basic_json_parser_36;
                        basic_json_parser_33:
                        m_cursor = m_marker;
                        if (yyaccept == 0)
                        {
                            goto basic_json_parser_5;
                        }
                        else
                        {
                            goto basic_json_parser_14;
                        }
                        basic_json_parser_34:
                        ++m_cursor;
                        {
                            last_token_type = token_type::value_string;
                            break;
                        }
                        basic_json_parser_36:
                        ++m_cursor;
                        if (m_limit <= m_cursor)
                        {
                            fill_line_buffer();
                        }
                        yych = *m_cursor;
                        if (yych <= 'e')
                        {
                            if (yych <= '/')
                            {
                                if (yych == '"')
                                {
                                    goto basic_json_parser_31;
                                }
                                if (yych <= '.')
                                {
                                    goto basic_json_parser_33;
                                }
                                goto basic_json_parser_31;
                            }
                            else
                            {
                                if (yych <= '\\')
                                {
                                    if (yych <= '[')
                                    {
                                        goto basic_json_parser_33;
                                    }
                                    goto basic_json_parser_31;
                                }
                                else
                                {
                                    if (yych == 'b')
                                    {
                                        goto basic_json_parser_31;
                                    }
                                    goto basic_json_parser_33;
                                }
                            }
                        }
                        else
                        {
                            if (yych <= 'q')
                            {
                                if (yych <= 'f')
                                {
                                    goto basic_json_parser_31;
                                }
                                if (yych == 'n')
                                {
                                    goto basic_json_parser_31;
                                }
                                goto basic_json_parser_33;
                            }
                            else
                            {
                                if (yych <= 's')
                                {
                                    if (yych <= 'r')
                                    {
                                        goto basic_json_parser_31;
                                    }
                                    goto basic_json_parser_33;
                                }
                                else
                                {
                                    if (yych <= 't')
                                    {
                                        goto basic_json_parser_31;
                                    }
                                    if (yych <= 'u')
                                    {
                                        goto basic_json_parser_43;
                                    }
                                    goto basic_json_parser_33;
                                }
                            }
                        }
                        basic_json_parser_37:
                        yych = *++m_cursor;
                        if (yych <= '/')
                        {
                            goto basic_json_parser_33;
                        }
                        if (yych <= '9')
                        {
                            goto basic_json_parser_44;
                        }
                        goto basic_json_parser_33;
                        basic_json_parser_38:
                        yych = *++m_cursor;
                        if (yych <= ',')
                        {
                            if (yych == '+')
                            {
                                goto basic_json_parser_46;
                            }
                            goto basic_json_parser_33;
                        }
                        else
                        {
                            if (yych <= '-')
                            {
                                goto basic_json_parser_46;
                            }
                            if (yych <= '/')
                            {
                                goto basic_json_parser_33;
                            }
                            if (yych <= '9')
                            {
                                goto basic_json_parser_47;
                            }
                            goto basic_json_parser_33;
                        }
                        basic_json_parser_39:
                        yych = *++m_cursor;
                        if (yych == 'l')
                        {
                            goto basic_json_parser_49;
                        }
                        goto basic_json_parser_33;
                        basic_json_parser_40:
                        yych = *++m_cursor;
                        if (yych == 'l')
                        {
                            goto basic_json_parser_50;
                        }
                        goto basic_json_parser_33;
                        basic_json_parser_41:
                        yych = *++m_cursor;
                        if (yych == 'u')
                        {
                            goto basic_json_parser_51;
                        }
                        goto basic_json_parser_33;
                        basic_json_parser_42:
                        yych = *++m_cursor;
                        if (yych == 0xBF)
                        {
                            goto basic_json_parser_52;
                        }
                        goto basic_json_parser_33;
                        basic_json_parser_43:
                        ++m_cursor;
                        if (m_limit <= m_cursor)
                        {
                            fill_line_buffer();
                        }
                        yych = *m_cursor;
                        if (yych <= '@')
                        {
                            if (yych <= '/')
                            {
                                goto basic_json_parser_33;
                            }
                            if (yych <= '9')
                            {
                                goto basic_json_parser_54;
                            }
                            goto basic_json_parser_33;
                        }
                        else
                        {
                            if (yych <= 'F')
                            {
                                goto basic_json_parser_54;
                            }
                            if (yych <= '`')
                            {
                                goto basic_json_parser_33;
                            }
                            if (yych <= 'f')
                            {
                                goto basic_json_parser_54;
                            }
                            goto basic_json_parser_33;
                        }
                        basic_json_parser_44:
                        yyaccept = 1;
                        m_marker = ++m_cursor;
                        if ((m_limit - m_cursor) < 3)
                        {
                            fill_line_buffer();
                        }
                        yych = *m_cursor;
                        if (yych <= 'D')
                        {
                            if (yych <= '/')
                            {
                                goto basic_json_parser_14;
                            }
                            if (yych <= '9')
                            {
                                goto basic_json_parser_44;
                            }
                            goto basic_json_parser_14;
                        }
                        else
                        {
                            if (yych <= 'E')
                            {
                                goto basic_json_parser_38;
                            }
                            if (yych == 'e')
                            {
                                goto basic_json_parser_38;
                            }
                            goto basic_json_parser_14;
                        }
                        basic_json_parser_46:
                        yych = *++m_cursor;
                        if (yych <= '/')
                        {
                            goto basic_json_parser_33;
                        }
                        if (yych >= ':')
                        {
                            goto basic_json_parser_33;
                        }
                        basic_json_parser_47:
                        ++m_cursor;
                        if (m_limit <= m_cursor)
                        {
                            fill_line_buffer();
                        }
                        yych = *m_cursor;
                        if (yych <= '/')
                        {
                            goto basic_json_parser_14;
                        }
                        if (yych <= '9')
                        {
                            goto basic_json_parser_47;
                        }
                        goto basic_json_parser_14;
                        basic_json_parser_49:
                        yych = *++m_cursor;
                        if (yych == 's')
                        {
                            goto basic_json_parser_55;
                        }
                        goto basic_json_parser_33;
                        basic_json_parser_50:
                        yych = *++m_cursor;
                        if (yych == 'l')
                        {
                            goto basic_json_parser_56;
                        }
                        goto basic_json_parser_33;
                        basic_json_parser_51:
                        yych = *++m_cursor;
                        if (yych == 'e')
                        {
                            goto basic_json_parser_58;
                        }
                        goto basic_json_parser_33;
                        basic_json_parser_52:
                        ++m_cursor;
                        {
                            continue;
                        }
                        basic_json_parser_54:
                        ++m_cursor;
                        if (m_limit <= m_cursor)
                        {
                            fill_line_buffer();
                        }
                        yych = *m_cursor;
                        if (yych <= '@')
                        {
                            if (yych <= '/')
                            {
                                goto basic_json_parser_33;
                            }
                            if (yych <= '9')
                            {
                                goto basic_json_parser_60;
                            }
                            goto basic_json_parser_33;
                        }
                        else
                        {
                            if (yych <= 'F')
                            {
                                goto basic_json_parser_60;
                            }
                            if (yych <= '`')
                            {
                                goto basic_json_parser_33;
                            }
                            if (yych <= 'f')
                            {
                                goto basic_json_parser_60;
                            }
                            goto basic_json_parser_33;
                        }
                        basic_json_parser_55:
                        yych = *++m_cursor;
                        if (yych == 'e')
                        {
                            goto basic_json_parser_61;
                        }
                        goto basic_json_parser_33;
                        basic_json_parser_56:
                        ++m_cursor;
                        {
                            last_token_type = token_type::literal_null;
                            break;
                        }
                        basic_json_parser_58:
                        ++m_cursor;
                        {
                            last_token_type = token_type::literal_true;
                            break;
                        }
                        basic_json_parser_60:
                        ++m_cursor;
                        if (m_limit <= m_cursor)
                        {
                            fill_line_buffer();
                        }
                        yych = *m_cursor;
                        if (yych <= '@')
                        {
                            if (yych <= '/')
                            {
                                goto basic_json_parser_33;
                            }
                            if (yych <= '9')
                            {
                                goto basic_json_parser_63;
                            }
                            goto basic_json_parser_33;
                        }
                        else
                        {
                            if (yych <= 'F')
                            {
                                goto basic_json_parser_63;
                            }
                            if (yych <= '`')
                            {
                                goto basic_json_parser_33;
                            }
                            if (yych <= 'f')
                            {
                                goto basic_json_parser_63;
                            }
                            goto basic_json_parser_33;
                        }
                        basic_json_parser_61:
                        ++m_cursor;
                        {
                            last_token_type = token_type::literal_false;
                            break;
                        }
                        basic_json_parser_63:
                        ++m_cursor;
                        if (m_limit <= m_cursor)
                        {
                            fill_line_buffer();
                        }
                        yych = *m_cursor;
                        if (yych <= '@')
                        {
                            if (yych <= '/')
                            {
                                goto basic_json_parser_33;
                            }
                            if (yych <= '9')
                            {
                                goto basic_json_parser_31;
                            }
                            goto basic_json_parser_33;
                        }
                        else
                        {
                            if (yych <= 'F')
                            {
                                goto basic_json_parser_31;
                            }
                            if (yych <= '`')
                            {
                                goto basic_json_parser_33;
                            }
                            if (yych <= 'f')
                            {
                                goto basic_json_parser_31;
                            }
                            goto basic_json_parser_33;
                        }
                    }

                }

                return last_token_type;
            }

            void fill_line_buffer()
            {
                // number of processed characters (p)
                const auto offset_start = m_start - m_content;
                // offset for m_marker wrt. to m_start
                const auto offset_marker = (m_marker == nullptr) ? 0 : m_marker - m_start;
                // number of unprocessed characters (u)
                const auto offset_cursor = m_cursor - m_start;

                // no stream is used or end of file is reached
                if (m_stream == nullptr or m_stream->eof())
                {
                    // copy unprocessed characters to line buffer
                    m_line_buffer.clear();
                    for (m_cursor = m_start; m_cursor != m_limit; ++m_cursor)
                    {
                        m_line_buffer.append(1, static_cast<const char>(*m_cursor));
                    }

                    // append 5 characters (size of longest keyword "false") to
                    // make sure that there is sufficient space between m_cursor
                    // and m_limit
                    m_line_buffer.append(5, '\0');
                }
                else
                {
                    // delete processed characters from line buffer
                    m_line_buffer.erase(0, static_cast<size_t>(offset_start));
                    // read next line from input stream
                    std::string line;
                    std::getline(*m_stream, line);
                    // add line with newline symbol to the line buffer
                    m_line_buffer += line + "\n";
                }

                // set pointers
                m_content = reinterpret_cast<const lexer_char_t*>(m_line_buffer.c_str());
                assert(m_content != nullptr);
                m_start  = m_content;
                m_marker = m_start + offset_marker;
                m_cursor = m_start + offset_cursor;
                m_limit  = m_start + m_line_buffer.size();
            }

            string_t get_token_string() const
            {
                assert(m_start != nullptr);
                return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),
                        static_cast<size_t>(m_cursor - m_start));
            }

            string_t get_string() const
            {
                assert(m_cursor - m_start >= 2);

                string_t result;
                result.reserve(static_cast<size_t>(m_cursor - m_start - 2));

                // iterate the result between the quotes
                for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
                {
                    // process escaped characters
                    if (*i == '\\')
                    {
                        // read next character
                        ++i;

                        switch (*i)
                        {
                            // the default escapes
                            case 't':
                            {
                                result += "\t";
                                break;
                            }
                            case 'b':
                            {
                                result += "\b";
                                break;
                            }
                            case 'f':
                            {
                                result += "\f";
                                break;
                            }
                            case 'n':
                            {
                                result += "\n";
                                break;
                            }
                            case 'r':
                            {
                                result += "\r";
                                break;
                            }
                            case '\\':
                            {
                                result += "\\";
                                break;
                            }
                            case '/':
                            {
                                result += "/";
                                break;
                            }
                            case '"':
                            {
                                result += "\"";
                                break;
                            }

                                // unicode
                            case 'u':
                            {
                                // get code xxxx from uxxxx
                                auto codepoint = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>(i + 1),
                                        4).c_str(), nullptr, 16);

                                // check if codepoint is a high surrogate
                                if (codepoint >= 0xD800 and codepoint <= 0xDBFF)
                                {
                                    // make sure there is a subsequent unicode
                                    if ((i + 6 >= m_limit) or * (i + 5) != '\\' or * (i + 6) != 'u')
                                    {
                                        throw std::invalid_argument("missing low surrogate");
                                    }

                                    // get code yyyy from uxxxx\uyyyy
                                    auto codepoint2 = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>
                                                                                                         (i + 7), 4).c_str(), nullptr, 16);
                                    result += to_unicode(codepoint, codepoint2);
                                    // skip the next 10 characters (xxxx\uyyyy)
                                    i += 10;
                                }
                                else
                                {
                                    // add unicode character(s)
                                    result += to_unicode(codepoint);
                                    // skip the next four characters (xxxx)
                                    i += 4;
                                }
                                break;
                            }
                        }
                    }
                    else
                    {
                        // all other characters are just copied to the end of the
                        // string
                        result.append(1, static_cast<typename string_t::value_type>(*i));
                    }
                }

                return result;
            }

            long double str_to_float_t(long double* /* type */, char** endptr) const
            {
                return std::strtold(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
            }

            double str_to_float_t(double* /* type */, char** endptr) const
            {
                return std::strtod(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
            }

            float str_to_float_t(float* /* type */, char** endptr) const
            {
                return std::strtof(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
            }

            void get_number(basic_json& result) const
            {
                assert(m_start != nullptr);

                const lexer::lexer_char_t* curptr = m_start;

                // accumulate the integer conversion result (unsigned for now)
                number_unsigned_t value = 0;

                // maximum absolute value of the relevant integer type
                number_unsigned_t max;

                // temporarily store the type to avoid unecessary bitfield access
                value_t type;

                // look for sign
                if (*curptr == '-')
                {
                    type = value_t::number_integer;
                    max = static_cast<uint64_t>((std::numeric_limits<number_integer_t>::max)()) + 1;
                    curptr++;
                }
                else
                {
                    type = value_t::number_unsigned;
                    max = static_cast<uint64_t>((std::numeric_limits<number_unsigned_t>::max)());
                }

                // count the significant figures
                for (; curptr < m_cursor; curptr++)
                {
                    // quickly skip tests if a digit
                    if (*curptr < '0' || *curptr > '9')
                    {
                        if (*curptr == '.')
                        {
                            // don't count '.' but change to float
                            type = value_t::number_float;
                            continue;
                        }
                        // assume exponent (if not then will fail parse): change to
                        // float, stop counting and record exponent details
                        type = value_t::number_float;
                        break;
                    }

                    // skip if definitely not an integer
                    if (type != value_t::number_float)
                    {
                        // multiply last value by ten and add the new digit
                        auto temp = value * 10 + *curptr - '0';

                        // test for overflow
                        if (temp < value || temp > max)
                        {
                            // overflow
                            type = value_t::number_float;
                        }
                        else
                        {
                            // no overflow - save it
                            value = temp;
                        }
                    }
                }

                // save the value (if not a float)
                if (type == value_t::number_unsigned)
                {
                    result.m_value.number_unsigned = value;
                }
                else if (type == value_t::number_integer)
                {
                    result.m_value.number_integer = -static_cast<number_integer_t>(value);
                }
                else
                {
                    // parse with strtod
                    result.m_value.number_float = str_to_float_t(static_cast<number_float_t*>(nullptr), NULL);
                }

                // save the type
                result.m_type = type;
            }

            private:
            std::istream* m_stream = nullptr;
            string_t m_line_buffer {};
            const lexer_char_t* m_content = nullptr;
            const lexer_char_t* m_start = nullptr;
            const lexer_char_t* m_marker = nullptr;
            const lexer_char_t* m_cursor = nullptr;
            const lexer_char_t* m_limit = nullptr;
            token_type last_token_type = token_type::end_of_input;
        };

        class parser
        {
            public:
            parser(const char* buff, const parser_callback_t cb = nullptr)
            : callback(cb),
                    m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(buff), strlen(buff))
            {}

            parser(std::istream& is, const parser_callback_t cb = nullptr)
            : callback(cb), m_lexer(is)
            {}

            template<class IteratorType, typename std::enable_if<
                                                  std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value
                    , int>::type
                                  = 0>
                                    parser(IteratorType first, IteratorType last, const parser_callback_t cb = nullptr)
            : callback(cb),
                    m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(&(*first)),
                    static_cast<size_t>(std::distance(first, last)))
            {}

            basic_json parse()
            {
                // read first token
                get_token();

                basic_json result = parse_internal(true);
                result.assert_invariant();

                expect(lexer::token_type::end_of_input);

                // return parser result and replace it with null in case the
                // top-level value was discarded by the callback function
                return result.is_discarded() ? basic_json() : std::move(result);
            }

            private:
            basic_json parse_internal(bool keep)
            {
                auto result = basic_json(value_t::discarded);

                switch (last_token)
                {
                    case lexer::token_type::begin_object:
                    {
                        if (keep and (not callback
                                      or ((keep = callback(depth++, parse_event_t::object_start, result)) != 0)))
                        {
                            // explicitly set result to object to cope with {}
                            result.m_type = value_t::object;
                            result.m_value = value_t::object;
                        }

                        // read next token
                        get_token();

                        // closing } -> we are done
                        if (last_token == lexer::token_type::end_object)
                        {
                            get_token();
                            if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
                            {
                                result = basic_json(value_t::discarded);
                            }
                            return result;
                        }

                        // no comma is expected here
                        unexpect(lexer::token_type::value_separator);

                        // otherwise: parse key-value pairs
                        do
                        {
                            // ugly, but could be fixed with loop reorganization
                            if (last_token == lexer::token_type::value_separator)
                            {
                                get_token();
                            }

                            // store key
                            expect(lexer::token_type::value_string);
                            const auto key = m_lexer.get_string();

                            bool keep_tag = false;
                            if (keep)
                            {
                                if (callback)
                                {
                                    basic_json k(key);
                                    keep_tag = callback(depth, parse_event_t::key, k);
                                }
                                else
                                {
                                    keep_tag = true;
                                }
                            }

                            // parse separator (:)
                            get_token();
                            expect(lexer::token_type::name_separator);

                            // parse and add value
                            get_token();
                            auto value = parse_internal(keep);
                            if (keep and keep_tag and not value.is_discarded())
                            {
                                result[key] = std::move(value);
                            }
                        }
                        while (last_token == lexer::token_type::value_separator);

                        // closing }
                        expect(lexer::token_type::end_object);
                        get_token();
                        if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
                        {
                            result = basic_json(value_t::discarded);
                        }

                        return result;
                    }

                    case lexer::token_type::begin_array:
                    {
                        if (keep and (not callback
                                      or ((keep = callback(depth++, parse_event_t::array_start, result)) != 0)))
                        {
                            // explicitly set result to object to cope with []
                            result.m_type = value_t::array;
                            result.m_value = value_t::array;
                        }

                        // read next token
                        get_token();

                        // closing ] -> we are done
                        if (last_token == lexer::token_type::end_array)
                        {
                            get_token();
                            if (callback and not callback(--depth, parse_event_t::array_end, result))
                            {
                                result = basic_json(value_t::discarded);
                            }
                            return result;
                        }

                        // no comma is expected here
                        unexpect(lexer::token_type::value_separator);

                        // otherwise: parse values
                        do
                        {
                            // ugly, but could be fixed with loop reorganization
                            if (last_token == lexer::token_type::value_separator)
                            {
                                get_token();
                            }

                            // parse value
                            auto value = parse_internal(keep);
                            if (keep and not value.is_discarded())
                            {
                                result.push_back(std::move(value));
                            }
                        }
                        while (last_token == lexer::token_type::value_separator);

                        // closing ]
                        expect(lexer::token_type::end_array);
                        get_token();
                        if (keep and callback and not callback(--depth, parse_event_t::array_end, result))
                        {
                            result = basic_json(value_t::discarded);
                        }

                        return result;
                    }

                    case lexer::token_type::literal_null:
                    {
                        get_token();
                        result.m_type = value_t::null;
                        break;
                    }

                    case lexer::token_type::value_string:
                    {
                        const auto s = m_lexer.get_string();
                        get_token();
                        result = basic_json(s);
                        break;
                    }

                    case lexer::token_type::literal_true:
                    {
                        get_token();
                        result.m_type = value_t::boolean;
                        result.m_value = true;
                        break;
                    }

                    case lexer::token_type::literal_false:
                    {
                        get_token();
                        result.m_type = value_t::boolean;
                        result.m_value = false;
                        break;
                    }

                    case lexer::token_type::value_number:
                    {
                        m_lexer.get_number(result);
                        get_token();
                        break;
                    }

                    default:
                    {
                        // the last token was unexpected
                        unexpect(last_token);
                    }
                }

                if (keep and callback and not callback(depth, parse_event_t::value, result))
                {
                    result = basic_json(value_t::discarded);
                }
                return result;
            }

            typename lexer::token_type get_token()
            {
                last_token = m_lexer.scan();
                return last_token;
            }

            void expect(typename lexer::token_type t) const
            {
                if (t != last_token)
                {
                    std::string error_msg = "parse error - unexpected ";
                    error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token_string() +
                                                                                  "'") :
                                  lexer::token_type_name(last_token));
                    error_msg += "; expected " + lexer::token_type_name(t);
                    throw std::invalid_argument(error_msg);
                }
            }

            void unexpect(typename lexer::token_type t) const
            {
                if (t == last_token)
                {
                    std::string error_msg = "parse error - unexpected ";
                    error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token_string() +
                                                                                  "'") :
                                  lexer::token_type_name(last_token));
                    throw std::invalid_argument(error_msg);
                }
            }

            private:
            int depth = 0;
            const parser_callback_t callback = nullptr;
            typename lexer::token_type last_token = lexer::token_type::uninitialized;
            lexer m_lexer;
        };

        public:
        class json_pointer
        {
            friend class basic_json;

            public:
            explicit json_pointer(const std::string& s = "")
            : reference_tokens(split(s))
            {}

            std::string to_string() const noexcept
            {
                return std::accumulate(reference_tokens.begin(),
                                       reference_tokens.end(), std::string{},
                [](const std::string & a, const std::string & b)
                {
                    return a + "/" + escape(b);
                });
            }

            operator std::string() const
            {
                return to_string();
            }

            private:
            std::string pop_back()
            {
                if (is_root())
                {
                    throw std::domain_error("JSON pointer has no parent");
                }

                auto last = reference_tokens.back();
                reference_tokens.pop_back();
                return last;
            }

            bool is_root() const
            {
                return reference_tokens.empty();
            }

            json_pointer top() const
            {
                if (is_root())
                {
                    throw std::domain_error("JSON pointer has no parent");
                }

                json_pointer result = *this;
                result.reference_tokens = {reference_tokens[0]};
                return result;
            }

            reference get_and_create(reference j) const
            {
                pointer result = &j;

                // in case no reference tokens exist, return a reference to the
                // JSON value j which will be overwritten by a primitive value
                for (const auto& reference_token : reference_tokens)
                {
                    switch (result->m_type)
                    {
                        case value_t::null:
                        {
                            if (reference_token == "0")
                            {
                                // start a new array if reference token is 0
                                result = &result->operator[](0);
                            }
                            else
                            {
                                // start a new object otherwise
                                result = &result->operator[](reference_token);
                            }
                            break;
                        }

                        case value_t::object:
                        {
                            // create an entry in the object
                            result = &result->operator[](reference_token);
                            break;
                        }

                        case value_t::array:
                        {
                            // create an entry in the array
                            result = &result->operator[](static_cast<size_type>(std::stoi(reference_token)));
                            break;
                        }

                            /*
                    The following code is only reached if there exists a
                    reference token _and_ the current value is primitive. In
                    this case, we have an error situation, because primitive
                    values may only occur as single value; that is, with an
                    empty list of reference tokens.
                    */
                        default:
                        {
                            throw std::domain_error("invalid value to unflatten");
                        }
                    }
                }

                return *result;
            }

            reference get_unchecked(pointer ptr) const
            {
                for (const auto& reference_token : reference_tokens)
                {
                    switch (ptr->m_type)
                    {
                        case value_t::object:
                        {
                            // use unchecked object access
                            ptr = &ptr->operator[](reference_token);
                            break;
                        }

                        case value_t::array:
                        {
                            // error condition (cf. RFC 6901, Sect. 4)
                            if (reference_token.size() > 1 and reference_token[0] == '0')
                            {
                                throw std::domain_error("array index must not begin with '0'");
                            }

                            if (reference_token == "-")
                            {
                                // explicityly treat "-" as index beyond the end
                                ptr = &ptr->operator[](ptr->m_value.array->size());
                            }
                            else
                            {
                                // convert array index to number; unchecked access
                                ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
                            }
                            break;
                        }

                        default:
                        {
                            throw std::out_of_range("unresolved reference token '" + reference_token + "'");
                        }
                    }
                }

                return *ptr;
            }

            reference get_checked(pointer ptr) const
            {
                for (const auto& reference_token : reference_tokens)
                {
                    switch (ptr->m_type)
                    {
                        case value_t::object:
                        {
                            // note: at performs range check
                            ptr = &ptr->at(reference_token);
                            break;
                        }

                        case value_t::array:
                        {
                            if (reference_token == "-")
                            {
                                // "-" always fails the range check
                                throw std::out_of_range("array index '-' (" +
                                                        std::to_string(ptr->m_value.array->size()) +
                                                        ") is out of range");
                            }

                            // error condition (cf. RFC 6901, Sect. 4)
                            if (reference_token.size() > 1 and reference_token[0] == '0')
                            {
                                throw std::domain_error("array index must not begin with '0'");
                            }

                            // note: at performs range check
                            ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
                            break;
                        }

                        default:
                        {
                            throw std::out_of_range("unresolved reference token '" + reference_token + "'");
                        }
                    }
                }

                return *ptr;
            }

            const_reference get_unchecked(const_pointer ptr) const
            {
                for (const auto& reference_token : reference_tokens)
                {
                    switch (ptr->m_type)
                    {
                        case value_t::object:
                        {
                            // use unchecked object access
                            ptr = &ptr->operator[](reference_token);
                            break;
                        }

                        case value_t::array:
                        {
                            if (reference_token == "-")
                            {
                                // "-" cannot be used for const access
                                throw std::out_of_range("array index '-' (" +
                                                        std::to_string(ptr->m_value.array->size()) +
                                                        ") is out of range");
                            }

                            // error condition (cf. RFC 6901, Sect. 4)
                            if (reference_token.size() > 1 and reference_token[0] == '0')
                            {
                                throw std::domain_error("array index must not begin with '0'");
                            }

                            // use unchecked array access
                            ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
                            break;
                        }

                        default:
                        {
                            throw std::out_of_range("unresolved reference token '" + reference_token + "'");
                        }
                    }
                }

                return *ptr;
            }

            const_reference get_checked(const_pointer ptr) const
            {
                for (const auto& reference_token : reference_tokens)
                {
                    switch (ptr->m_type)
                    {
                        case value_t::object:
                        {
                            // note: at performs range check
                            ptr = &ptr->at(reference_token);
                            break;
                        }

                        case value_t::array:
                        {
                            if (reference_token == "-")
                            {
                                // "-" always fails the range check
                                throw std::out_of_range("array index '-' (" +
                                                        std::to_string(ptr->m_value.array->size()) +
                                                        ") is out of range");
                            }

                            // error condition (cf. RFC 6901, Sect. 4)
                            if (reference_token.size() > 1 and reference_token[0] == '0')
                            {
                                throw std::domain_error("array index must not begin with '0'");
                            }

                            // note: at performs range check
                            ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
                            break;
                        }

                        default:
                        {
                            throw std::out_of_range("unresolved reference token '" + reference_token + "'");
                        }
                    }
                }

                return *ptr;
            }

            static std::vector<std::string> split(const std::string& reference_string)
            {
                std::vector<std::string> result;

                // special case: empty reference string -> no reference tokens
                if (reference_string.empty())
                {
                    return result;
                }

                // check if nonempty reference string begins with slash
                if (reference_string[0] != '/')
                {
                    throw std::domain_error("JSON pointer must be empty or begin with '/'");
                }

                // extract the reference tokens:
                // - slash: position of the last read slash (or end of string)
                // - start: position after the previous slash
                for (
                    // search for the first slash after the first character
                        size_t slash = reference_string.find_first_of("/", 1),
                        // set the beginning of the first reference token
                                start = 1;
                    // we can stop if start == string::npos+1 = 0
                        start != 0;
                    // set the beginning of the next reference token
                    // (will eventually be 0 if slash == std::string::npos)
                        start = slash + 1,
                                // find next slash
                                slash = reference_string.find_first_of("/", start))
                {
                    // use the text between the beginning of the reference token
                    // (start) and the last slash (slash).
                    auto reference_token = reference_string.substr(start, slash - start);

                    // check reference tokens are properly escaped
                    for (size_t pos = reference_token.find_first_of("~");
                         pos != std::string::npos;
                         pos = reference_token.find_first_of("~", pos + 1))
                    {
                        assert(reference_token[pos] == '~');

                        // ~ must be followed by 0 or 1
                        if (pos == reference_token.size() - 1 or
                                    (reference_token[pos + 1] != '0' and
                        reference_token[pos + 1] != '1'))
                        {
                            throw std::domain_error("escape error: '~' must be followed with '0' or '1'");
                        }
                    }

                    // finally, store the reference token
                    unescape(reference_token);
                    result.push_back(reference_token);
                }

                return result;
            }

            private:
            static void replace_substring(std::string& s,
                    const std::string& f,
            const std::string& t)
            {
                assert(not f.empty());

                for (
                        size_t pos = s.find(f);         // find first occurrence of f
                        pos != std::string::npos;       // make sure f was found
                        s.replace(pos, f.size(), t),    // replace with t
                                pos = s.find(f, pos + t.size()) // find next occurrence of f
                        );
            }

            static std::string escape(std::string s)
            {
                // escape "~"" to "~0" and "/" to "~1"
                replace_substring(s, "~", "~0");
                replace_substring(s, "/", "~1");
                return s;
            }

            static void unescape(std::string& s)
            {
                // first transform any occurrence of the sequence '~1' to '/'
                replace_substring(s, "~1", "/");
                // then transform any occurrence of the sequence '~0' to '~'
                replace_substring(s, "~0", "~");
            }

            static void flatten(const std::string& reference_string,
            const basic_json& value,
                    basic_json& result)
            {
                switch (value.m_type)
                {
                    case value_t::array:
                    {
                        if (value.m_value.array->empty())
                        {
                            // flatten empty array as null
                            result[reference_string] = nullptr;
                        }
                        else
                        {
                            // iterate array and use index as reference string
                            for (size_t i = 0; i < value.m_value.array->size(); ++i)
                            {
                                flatten(reference_string + "/" + std::to_string(i),
                                        value.m_value.array->operator[](i), result);
                            }
                        }
                        break;
                    }

                    case value_t::object:
                    {
                        if (value.m_value.object->empty())
                        {
                            // flatten empty object as null
                            result[reference_string] = nullptr;
                        }
                        else
                        {
                            // iterate object and use keys as reference string
                            for (const auto& element : *value.m_value.object)
                            {
                                flatten(reference_string + "/" + escape(element.first),
                                        element.second, result);
                            }
                        }
                        break;
                    }

                    default:
                    {
                        // add primitive value with its reference string
                        result[reference_string] = value;
                        break;
                    }
                }
            }

            static basic_json unflatten(const basic_json& value)
            {
                if (not value.is_object())
                {
                    throw std::domain_error("only objects can be unflattened");
                }

                basic_json result;

                // iterate the JSON object values
                for (const auto& element : *value.m_value.object)
                {
                    if (not element.second.is_primitive())
                    {
                        throw std::domain_error("values in object must be primitive");
                    }

                    // assign value to reference pointed to by JSON pointer; Note
                    // that if the JSON pointer is "" (i.e., points to the whole
                    // value), function get_and_create returns a reference to
                    // result itself. An assignment will then create a primitive
                    // value.
                    json_pointer(element.first).get_and_create(result) = element.second;
                }

                return result;
            }

            private:
            std::vector<std::string> reference_tokens {};
        };

        // JSON Pointer support //


        reference operator[](const json_pointer& ptr)
        {
            return ptr.get_unchecked(this);
        }

        const_reference operator[](const json_pointer& ptr) const
        {
            return ptr.get_unchecked(this);
        }

        reference at(const json_pointer& ptr)
        {
            return ptr.get_checked(this);
        }

        const_reference at(const json_pointer& ptr) const
        {
            return ptr.get_checked(this);
        }

        basic_json flatten() const
        {
            basic_json result(value_t::object);
            json_pointer::flatten("", *this, result);
            return result;
        }

        basic_json unflatten() const
        {
            return json_pointer::unflatten(*this);
        }


        // JSON Patch functions //


        basic_json patch(const basic_json& json_patch) const
        {
            // make a working copy to apply the patch to
            basic_json result = *this;

            // the valid JSON Patch operations
            enum class patch_operations {add, remove, replace, move, copy, test, invalid};

            const auto get_op = [](const std::string op)
            {
                if (op == "add")
                {
                    return patch_operations::add;
                }
                if (op == "remove")
                {
                    return patch_operations::remove;
                }
                if (op == "replace")
                {
                    return patch_operations::replace;
                }
                if (op == "move")
                {
                    return patch_operations::move;
                }
                if (op == "copy")
                {
                    return patch_operations::copy;
                }
                if (op == "test")
                {
                    return patch_operations::test;
                }

                return patch_operations::invalid;
            };

            // wrapper for "add" operation; add value at ptr
            const auto operation_add = [&result](json_pointer & ptr, basic_json val)
            {
                // adding to the root of the target document means replacing it
                if (ptr.is_root())
                {
                    result = val;
                }
                else
                {
                    // make sure the top element of the pointer exists
                    json_pointer top_pointer = ptr.top();
                    if (top_pointer != ptr)
                    {
                        result.at(top_pointer);
                    }

                    // get reference to parent of JSON pointer ptr
                    const auto last_path = ptr.pop_back();
                    basic_json& parent = result[ptr];

                    switch (parent.m_type)
                    {
                        case value_t::null:
                        case value_t::object:
                        {
                            // use operator[] to add value
                            parent[last_path] = val;
                            break;
                        }

                        case value_t::array:
                        {
                            if (last_path == "-")
                            {
                                // special case: append to back
                                parent.push_back(val);
                            }
                            else
                            {
                                const auto idx = std::stoi(last_path);
                                if (static_cast<size_type>(idx) > parent.size())
                                {
                                    // avoid undefined behavior
                                    throw std::out_of_range("array index " + std::to_string(idx) + " is out of range");
                                }
                                else
                                {
                                    // default case: insert add offset
                                    parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
                                }
                            }
                            break;
                        }

                        default:
                        {
                            // if there exists a parent it cannot be primitive
                            assert(false);  // LCOV_EXCL_LINE
                        }
                    }
                }
            };

            // wrapper for "remove" operation; remove value at ptr
            const auto operation_remove = [&result](json_pointer & ptr)
            {
                // get reference to parent of JSON pointer ptr
                const auto last_path = ptr.pop_back();
                basic_json& parent = result.at(ptr);

                // remove child
                if (parent.is_object())
                {
                    // perform range check
                    auto it = parent.find(last_path);
                    if (it != parent.end())
                    {
                        parent.erase(it);
                    }
                    else
                    {
                        throw std::out_of_range("key '" + last_path + "' not found");
                    }
                }
                else if (parent.is_array())
                {
                    // note erase performs range check
                    parent.erase(static_cast<size_type>(std::stoi(last_path)));
                }
            };

            // type check
            if (not json_patch.is_array())
            {
                // a JSON patch must be an array of objects
                throw std::invalid_argument("JSON patch must be an array of objects");
            }

            // iterate and apply th eoperations
            for (const auto& val : json_patch)
            {
                // wrapper to get a value for an operation
                const auto get_value = [&val](const std::string & op,
                const std::string & member,
                        bool string_type) -> basic_json&
                                             {
                                                     // find value
                                                     auto it = val.m_value.object->find(member);

                                                     // context-sensitive error message
                                                     const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";

                                                     // check if desired value is present
                                                     if (it == val.m_value.object->end())
                                                     {
                                                         throw std::invalid_argument(error_msg + " must have member '" + member + "'");
                                                     }

                                                     // check if result is of type string
                                                     if (string_type and not it->second.is_string())
                                                     {
                                                         throw std::invalid_argument(error_msg + " must have string member '" + member + "'");
                                                     }

                                                     // no error: return value
                                                     return it->second;
                                             };

                // type check
                if (not val.is_object())
                {
                    throw std::invalid_argument("JSON patch must be an array of objects");
                }

                // collect mandatory members
                const std::string op = get_value("op", "op", true);
                const std::string path = get_value(op, "path", true);
                json_pointer ptr(path);

                switch (get_op(op))
                {
                    case patch_operations::add:
                    {
                        operation_add(ptr, get_value("add", "value", false));
                        break;
                    }

                    case patch_operations::remove:
                    {
                        operation_remove(ptr);
                        break;
                    }

                    case patch_operations::replace:
                    {
                        // the "path" location must exist - use at()
                        result.at(ptr) = get_value("replace", "value", false);
                        break;
                    }

                    case patch_operations::move:
                    {
                        const std::string from_path = get_value("move", "from", true);
                        json_pointer from_ptr(from_path);

                        // the "from" location must exist - use at()
                        basic_json v = result.at(from_ptr);

                        // The move operation is functionally identical to a
                        // "remove" operation on the "from" location, followed
                        // immediately by an "add" operation at the target
                        // location with the value that was just removed.
                        operation_remove(from_ptr);
                        operation_add(ptr, v);
                        break;
                    }

                    case patch_operations::copy:
                    {
                        const std::string from_path = get_value("copy", "from", true);;
                        const json_pointer from_ptr(from_path);

                        // the "from" location must exist - use at()
                        result[ptr] = result.at(from_ptr);
                        break;
                    }

                    case patch_operations::test:
                    {
                        bool success = false;
                        try
                        {
                            // check if "value" matches the one at "path"
                            // the "path" location must exist - use at()
                            success = (result.at(ptr) == get_value("test", "value", false));
                        }
                        catch (std::out_of_range&)
                        {
                            // ignore out of range errors: success remains false
                        }

                        // throw an exception if test fails
                        if (not success)
                        {
                            throw std::domain_error("unsuccessful: " + val.dump());
                        }

                        break;
                    }

                    case patch_operations::invalid:
                    {
                        // op must be "add", "remove", "replace", "move", "copy", or
                        // "test"
                        throw std::invalid_argument("operation value '" + op + "' is invalid");
                    }
                }
            }

            return result;
        }

        static basic_json diff(const basic_json& source,
        const basic_json& target,
        const std::string& path = "")
        {
            // the patch
            basic_json result(value_t::array);

            // if the values are the same, return empty patch
            if (source == target)
            {
                return result;
            }

            if (source.type() != target.type())
            {
                // different types: replace value
                result.push_back(
                        {
                                {"op", "replace"},
                                {"path", path},
                                {"value", target}
                        });
            }
            else
            {
                switch (source.type())
                {
                    case value_t::array:
                    {
                        // first pass: traverse common elements
                        size_t i = 0;
                        while (i < source.size() and i < target.size())
                        {
                            // recursive call to compare array values at index i
                            auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
                            result.insert(result.end(), temp_diff.begin(), temp_diff.end());
                            ++i;
                        }

                        // i now reached the end of at least one array
                        // in a second pass, traverse the remaining elements

                        // remove my remaining elements
                        const auto end_index = static_cast<difference_type>(result.size());
                        while (i < source.size())
                        {
                            // add operations in reverse order to avoid invalid
                            // indices
                            result.insert(result.begin() + end_index, object(
                                    {
                                            {"op", "remove"},
                                            {"path", path + "/" + std::to_string(i)}
                                    }));
                            ++i;
                        }

                        // add other remaining elements
                        while (i < target.size())
                        {
                            result.push_back(
                                    {
                                            {"op", "add"},
                                            {"path", path + "/" + std::to_string(i)},
                                            {"value", target[i]}
                                    });
                            ++i;
                        }

                        break;
                    }

                    case value_t::object:
                    {
                        // first pass: traverse this object's elements
                        for (auto it = source.begin(); it != source.end(); ++it)
                        {
                            // escape the key name to be used in a JSON patch
                            const auto key = json_pointer::escape(it.key());

                            if (target.find(it.key()) != target.end())
                            {
                                // recursive call to compare object values at key it
                                auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);
                                result.insert(result.end(), temp_diff.begin(), temp_diff.end());
                            }
                            else
                            {
                                // found a key that is not in o -> remove it
                                result.push_back(object(
                                        {
                                                {"op", "remove"},
                                                {"path", path + "/" + key}
                                        }));
                            }
                        }

                        // second pass: traverse other object's elements
                        for (auto it = target.begin(); it != target.end(); ++it)
                        {
                            if (source.find(it.key()) == source.end())
                            {
                                // found a key that is not in this -> add it
                                const auto key = json_pointer::escape(it.key());
                                result.push_back(
                                        {
                                                {"op", "add"},
                                                {"path", path + "/" + key},
                                                {"value", it.value()}
                                        });
                            }
                        }

                        break;
                    }

                    default:
                    {
                        // both primitive type: replace value
                        result.push_back(
                                {
                                        {"op", "replace"},
                                        {"path", path},
                                        {"value", target}
                                });
                        break;
                    }
                }
            }

            return result;
        }

    };


// presets //

    using json = basic_json<>;
}


// nonmember support //

// specialization of std::swap, and std::hash
namespace std
{
    template<>
    inline void swap(nlohmann::json& j1,
    nlohmann::json& j2) noexcept(
            is_nothrow_move_constructible<nlohmann::json>::value and
    is_nothrow_move_assignable<nlohmann::json>::value
    )
    {
        j1.swap(j2);
    }

    template<>
    struct hash<nlohmann::json>
    {
        std::size_t operator()(const nlohmann::json& j) const
        {
            // a naive hashing via the string representation
            const auto& h = hash<nlohmann::json::string_t>();
            return h(j.dump());
        }
    };
}

inline nlohmann::json operator "" _json(const char* s, std::size_t)
{
    return nlohmann::json::parse(s);
}

inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t)
{
    return nlohmann::json::json_pointer(s);
}

using json = nlohmann::json;

// restore GCC/clang diagnostic settings
#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
#pragma GCC diagnostic pop
#endif

#endif