json_iterator.hpp

#pragma once
 
#include "fly/concepts/concepts.hpp"
#include "fly/types/json/concepts.hpp"
#include "fly/types/json/json_exception.hpp"
#include "fly/types/string/string.hpp"
 
#include <cmath>
#include <cstdint>
#include <iterator>
#include <type_traits>
#include <variant>
 
namespace fly {
class Json;
} // namespace fly
 
namespace fly::detail {
 
template <typename JsonIterator>
class JsonReverseIterator;
 
template <fly::SameAs<Json> JsonType>
class JsonIterator
{
    static constexpr bool is_const_iterator = std::is_const_v<JsonType>;
 
    using object_iterator_type = std::conditional_t<
        is_const_iterator,
        json_object_type::const_iterator,
        json_object_type::iterator>;
 
    using array_iterator_type = std::conditional_t<
        is_const_iterator,
        json_array_type::const_iterator,
        json_array_type::iterator>;
 
    using iterator_type = std::variant<object_iterator_type, array_iterator_type>;
 
    using ConstJsonIterator = JsonIterator<typename std::add_const_t<JsonType>>;
 
    using NonConstJsonIterator = JsonIterator<typename std::remove_const_t<JsonType>>;
 
public:
    using iterator_category = std::bidirectional_iterator_tag;
    using value_type = JsonType;
    using difference_type = typename JsonType::difference_type;
    using reference = std::conditional_t<
        is_const_iterator,
        typename JsonType::const_reference,
        typename JsonType::reference>;
    using pointer = std::conditional_t<
        is_const_iterator,
        typename JsonType::const_pointer,
        typename JsonType::pointer>;
 
    enum class Position : std::uint8_t
    {
        Begin,
        End,
    };
 
    JsonIterator() = default;
 
    JsonIterator(pointer json, Position position) noexcept(false);
 
    JsonIterator(const NonConstJsonIterator &iterator) noexcept;
 
    JsonIterator &operator=(const NonConstJsonIterator &iterator) noexcept;
 
    reference operator*() const;
 
    pointer operator->() const;
 
    reference operator[](difference_type offset) const;
 
    bool operator==(const JsonIterator &iterator) const;
 
    bool operator!=(const JsonIterator &iterator) const;
 
    bool operator<(const JsonIterator &iterator) const;
 
    bool operator<=(const JsonIterator &iterator) const;
 
    bool operator>(const JsonIterator &iterator) const;
 
    bool operator>=(const JsonIterator &iterator) const;
 
    JsonIterator operator++(int);
 
    JsonIterator &operator++();
 
    JsonIterator operator--(int);
 
    JsonIterator &operator--();
 
    JsonIterator &operator+=(difference_type offset);
 
    JsonIterator &operator-=(difference_type offset);
 
    JsonIterator operator+(difference_type offset) const;
 
    template <typename J>
    friend JsonIterator<J>
    operator+(typename JsonIterator<J>::difference_type offset, const JsonIterator<J> &iterator);
 
    JsonIterator operator-(difference_type offset) const;
 
    difference_type operator-(const JsonIterator &iterator) const;
 
    const typename json_object_type::key_type &key() const;
 
    reference value() const;
 
private:
    friend std::conditional_t<is_const_iterator, NonConstJsonIterator, ConstJsonIterator>;
    friend JsonReverseIterator<JsonIterator>;
    friend fly::Json;
 
    template <typename... Ts>
    static constexpr inline bool is_object_iterator = fly::SameAsAll<object_iterator_type, Ts...>;
 
    template <typename... Ts>
    static constexpr inline bool is_array_iterator = fly::SameAsAll<array_iterator_type, Ts...>;
 
    void validate_iterator() const;
 
    void validate_iterator(const JsonIterator &iterator) const;
 
    template <typename T>
    void validate_offset(const T &it, difference_type offset) const;
 
    template <typename T>
    void validate_dereference(const T &it) const;
 
    pointer m_json {nullptr};
    iterator_type m_iterator;
};
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
JsonIterator<JsonType>::JsonIterator(pointer json, Position position) noexcept(false) : m_json(json)
{
    auto visitor = [this, &position](auto &value) noexcept(JsonIterable<decltype(value)>) {
        if constexpr (JsonIterable<decltype(value)>)
        {
            switch (position)
            {
                case Position::Begin:
                    m_iterator = value.begin();
                    break;
                case Position::End:
                    m_iterator = value.end();
                    break;
            }
        }
        else
        {
            throw JsonIteratorException(*m_json, "JSON type invalid for iteration");
        }
    };
 
    if (m_json != nullptr)
    {
        std::visit(std::move(visitor), m_json->m_value);
    }
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
JsonIterator<JsonType>::JsonIterator(const NonConstJsonIterator &iterator) noexcept :
    m_json(iterator.m_json)
{
    auto visitor = [this](const auto &it) noexcept {
        m_iterator = it;
    };
 
    std::visit(std::move(visitor), iterator.m_iterator);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
JsonIterator<JsonType> &
JsonIterator<JsonType>::operator=(const NonConstJsonIterator &iterator) noexcept
{
    m_json = iterator.m_json;
 
    auto visitor = [this](const auto &it) noexcept {
        m_iterator = it;
    };
 
    std::visit(std::move(visitor), iterator.m_iterator);
    return *this;
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
auto JsonIterator<JsonType>::operator*() const -> reference
{
    validate_iterator();
 
    auto visitor = [this](const auto &it) -> reference {
        this->validate_dereference(it);
 
        if constexpr (is_object_iterator<decltype(it)>)
        {
            return it->second;
        }
        else if constexpr (is_array_iterator<decltype(it)>)
        {
            return *it;
        }
    };
 
    return std::visit(std::move(visitor), m_iterator);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
auto JsonIterator<JsonType>::operator->() const -> pointer
{
    validate_iterator();
 
    auto visitor = [this](const auto &it) -> pointer {
        this->validate_dereference(it);
 
        if constexpr (is_object_iterator<decltype(it)>)
        {
            return &(it->second);
        }
        else if constexpr (is_array_iterator<decltype(it)>)
        {
            return &(*it);
        }
    };
 
    return std::visit(std::move(visitor), m_iterator);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
auto JsonIterator<JsonType>::operator[](difference_type offset) const -> reference
{
    validate_iterator();
 
    auto visitor = [&](const auto &it) -> reference {
        if constexpr (is_array_iterator<decltype(it)>)
        {
            validate_offset(it, offset);
 
            auto next = std::next(it, offset);
            validate_dereference(next);
 
            return *next;
        }
        else
        {
            throw JsonIteratorException(*m_json, "JSON type invalid for offset operator");
        }
    };
 
    return std::visit(std::move(visitor), m_iterator);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
bool JsonIterator<JsonType>::operator==(const JsonIterator &iterator) const
{
    validate_iterator(iterator);
    return m_iterator == iterator.m_iterator;
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
bool JsonIterator<JsonType>::operator!=(const JsonIterator &iterator) const
{
    return !(*this == iterator);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
bool JsonIterator<JsonType>::operator<(const JsonIterator &iterator) const
{
    validate_iterator(iterator);
 
    auto visitor = [this](const auto &it1, const auto &it2) -> bool {
        if constexpr (is_array_iterator<decltype(it1), decltype(it2)>)
        {
            return it1 < it2;
        }
        else
        {
            throw JsonIteratorException(*m_json, "JSON type invalid for comparison operator");
        }
    };
 
    return std::visit(std::move(visitor), m_iterator, iterator.m_iterator);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
bool JsonIterator<JsonType>::operator<=(const JsonIterator &iterator) const
{
    return !(iterator < *this);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
bool JsonIterator<JsonType>::operator>(const JsonIterator &iterator) const
{
    return !(*this <= iterator);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
bool JsonIterator<JsonType>::operator>=(const JsonIterator &iterator) const
{
    return !(*this < iterator);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
auto JsonIterator<JsonType>::operator++(int) -> JsonIterator
{
    auto result = *this;
    ++(*this);
 
    return result;
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
auto JsonIterator<JsonType>::operator++() -> JsonIterator &
{
    validate_iterator();
 
    auto visitor = [this](auto &it) -> JsonIterator & {
        validate_offset(it, 1);
        std::advance(it, 1);
 
        return *this;
    };
 
    return std::visit(std::move(visitor), m_iterator);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
auto JsonIterator<JsonType>::operator--(int) -> JsonIterator
{
    auto result = *this;
    --(*this);
 
    return result;
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
auto JsonIterator<JsonType>::operator--() -> JsonIterator &
{
    validate_iterator();
 
    auto visitor = [this](auto &it) -> JsonIterator & {
        validate_offset(it, -1);
        std::advance(it, -1);
 
        return *this;
    };
 
    return std::visit(std::move(visitor), m_iterator);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
auto JsonIterator<JsonType>::operator+=(difference_type offset) -> JsonIterator &
{
    validate_iterator();
 
    auto visitor = [this, &offset](auto &it) {
        if constexpr (is_array_iterator<decltype(it)>)
        {
            validate_offset(it, offset);
            std::advance(it, offset);
        }
        else
        {
            throw JsonIteratorException(*m_json, "JSON type invalid for iterator offset");
        }
    };
 
    std::visit(std::move(visitor), m_iterator);
    return *this;
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
auto JsonIterator<JsonType>::operator-=(difference_type offset) -> JsonIterator &
{
    return *this += -offset;
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
auto JsonIterator<JsonType>::operator+(difference_type offset) const -> JsonIterator
{
    auto result = *this;
    result += offset;
 
    return result;
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
JsonIterator<JsonType> operator+(
    typename JsonIterator<JsonType>::difference_type offset,
    const JsonIterator<JsonType> &iterator)
{
    auto result = iterator;
    result += offset;
 
    return result;
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
auto JsonIterator<JsonType>::operator-(difference_type offset) const -> JsonIterator
{
    auto result = *this;
    result -= offset;
 
    return result;
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
auto JsonIterator<JsonType>::operator-(const JsonIterator &iterator) const -> difference_type
{
    validate_iterator(iterator);
 
    auto visitor = [this](const auto &it1, const auto &it2) -> difference_type {
        if constexpr (is_array_iterator<decltype(it1), decltype(it2)>)
        {
            return std::distance(it2, it1);
        }
        else
        {
            throw JsonIteratorException(*m_json, "JSON type invalid for iterator difference");
        }
    };
 
    return std::visit(std::move(visitor), m_iterator, iterator.m_iterator);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
const typename json_object_type::key_type &JsonIterator<JsonType>::key() const
{
    validate_iterator();
 
    auto visitor = [this](const auto &it) -> const typename json_object_type::key_type & {
        if constexpr (is_object_iterator<decltype(it)>)
        {
            validate_dereference(it);
            return it->first;
        }
        else
        {
            throw JsonIteratorException(*m_json, "JSON type is not keyed");
        }
    };
 
    return std::visit(std::move(visitor), m_iterator);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
auto JsonIterator<JsonType>::value() const -> reference
{
    return *(*this);
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
void JsonIterator<JsonType>::validate_iterator() const
{
    if (m_json == nullptr)
    {
        throw NullJsonException();
    }
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
void JsonIterator<JsonType>::validate_iterator(const JsonIterator &iterator) const
{
    validate_iterator();
    iterator.validate_iterator();
 
    if (m_json != iterator.m_json)
    {
        throw BadJsonComparisonException(*m_json, *iterator.m_json);
    }
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
template <typename T>
void JsonIterator<JsonType>::validate_offset(const T &it, difference_type offset) const
 
{
    difference_type distance = 0;
 
    if (offset >= 0)
    {
        const JsonIterator end = m_json->end();
        distance = std::distance(it, std::get<T>(end.m_iterator));
    }
    else
    {
        const JsonIterator begin = m_json->begin();
        distance = std::distance(std::get<T>(begin.m_iterator), it);
    }
 
    if (std::abs(offset) > distance)
    {
        throw OutOfRangeJsonException(*m_json, offset);
    }
}
 
//==================================================================================================
template <fly::SameAs<Json> JsonType>
template <typename T>
void JsonIterator<JsonType>::validate_dereference(const T &it) const
{
    const JsonIterator end = m_json->end();
 
    if (it == std::get<T>(end.m_iterator))
    {
        throw NullJsonException(*m_json);
    }
}
 
} // namespace fly::detail