document.hpp

//          Copyright Christian Manning 2013.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#ifndef JBSON_DOCUMENT_HPP
#define JBSON_DOCUMENT_HPP

#include <memory>
#include <vector>
#include <set>
#include <codecvt>

#include "detail/config.hpp"

JBSON_PUSH_DISABLE_DOCUMENTATION_WARNING
#include <boost/iterator/iterator_facade.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/optional.hpp>
JBSON_CLANG_POP_WARNINGS

#include "document_fwd.hpp"
#include "element_fwd.hpp"
#include "detail/traits.hpp"
#include "element.hpp"

namespace jbson {

struct invalid_document_size : jbson_error {
    const char* what() const noexcept override { return "invalid_document_size"; }
};

namespace detail {

template <typename Value, typename BaseIterator>
struct document_iter
    : boost::iterator_facade<document_iter<Value, BaseIterator>, Value, boost::forward_traversal_tag, Value&> {
    static_assert(detail::is_element<std::remove_const_t<Value>>::value, "");

    using element_type = Value;

    document_iter() = default;

    document_iter(BaseIterator it1, BaseIterator it2) : m_start(it1), m_end(it2) {
        if(m_start == m_end)
            return;
        m_cur = element_type{m_start, m_end};
    }

    template <class OtherValue, typename OtherIt>
    document_iter(const document_iter<OtherValue, OtherIt>& other,
                  std::enable_if_t<std::is_convertible<OtherValue, element_type>::value&&
                                       std::is_convertible<OtherIt, BaseIterator>::value>* = nullptr)
        : m_start(other.m_start), m_end(other.m_end) {
        if(m_start == m_end)
            return;
        m_cur = element_type{m_start, m_end};
    }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  private:
    friend class boost::iterator_core_access;
    template <typename, typename> friend struct document_iter;
    template <typename, typename> friend class jbson::basic_document;
#endif

    template <typename OtherValue, typename OtherIterator>
    bool equal(const document_iter<OtherValue, OtherIterator>& other) const {
        return other.m_start == m_start;
    }

    void increment() {
        if(m_start == m_end) {
            m_cur = boost::none;
            return;
        }

        std::advance(m_start, m_cur->size());
        if(m_start == m_end)
            m_cur = boost::none;
        else
            m_cur = element_type{m_start, m_end};
    }

    element_type& dereference() const {
        assert(m_cur);
        return const_cast<element_type&>(*m_cur);
    }

  private:
    BaseIterator m_start;
    BaseIterator m_end;
    boost::optional<std::remove_const_t<element_type>> m_cur;
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS

template <typename Container> void init_empty(Container& c);
#else
template <typename Container>
void init_empty(Container& c, std::enable_if_t<container_has_push_back<Container>::value>* = nullptr) {
    static constexpr std::array<char, 5> arr{{5, 0, 0, 0, '\0'}};
    boost::range::push_back(c, arr);
}

template <typename Container>
void init_empty(Container& c,
                std::enable_if_t<std::is_constructible<Container, std::array<char, 5>>::value>* = nullptr) {
    static constexpr std::array<char, 5> arr{{5, 0, 0, 0, '\0'}};
    c = arr;
}

template <typename Container>
void init_empty(Container&, std::enable_if_t<!container_has_push_back<Container>::value>* = nullptr,
                std::enable_if_t<!std::is_constructible<Container, std::array<char, 5>>::value>* = nullptr) {}

#endif // DOXYGEN_SHOULD_SKIP_THIS

} // namespace detail

struct builder;

enum class validity_level : uint8_t {
    data_size = 0,
    bson_size = 0b0001,
    element_construct = 0b0010,
    unicode_valid = 0b0100,
    array_indices = 0b1000
};

inline bool operator<(validity_level a, validity_level b) {
    return (std::underlying_type_t<validity_level>)a < (std::underlying_type_t<validity_level>)b;
}

inline bool operator>(validity_level a, validity_level b) { return b < a; }

inline validity_level operator&(validity_level a, validity_level b) {
    return static_cast<validity_level>((std::underlying_type_t<validity_level>)a &
                                       (std::underlying_type_t<validity_level>)b);
}

inline validity_level operator|(validity_level a, validity_level b) {
    return static_cast<validity_level>((std::underlying_type_t<validity_level>)a |
                                       (std::underlying_type_t<validity_level>)b);
}

template <class Container, class ElementContainer> class basic_document {
  public:
    using container_type = std::decay_t<Container>;
    static_assert(detail::is_nothrow_swappable<container_type>::value, "container_type must have noexcept swap()");

    using element_type = basic_element<ElementContainer>;
    using const_iterator = typename detail::document_iter<const element_type, typename container_type::const_iterator>;
    using iterator = const_iterator;
    using value_type = element_type;

    basic_document() { detail::init_empty(m_data); }

    template <typename SomeType>
    explicit basic_document(SomeType&& c,
                            std::enable_if_t<std::is_same<container_type, std::decay_t<SomeType>>::value>* = nullptr)
        : m_data(std::forward<SomeType>(c)) {
        if(!valid(validity_level::data_size))
            BOOST_THROW_EXCEPTION(invalid_document_size{} << detail::actual_size(boost::distance(m_data))
                                                          << detail::expected_size(sizeof(int32_t)));
        if(!valid(validity_level::bson_size))
            BOOST_THROW_EXCEPTION(invalid_document_size{}
                                  << detail::expected_size(
                                         detail::little_endian_to_native<int32_t>(m_data.begin(), m_data.end()))
                                  << detail::actual_size(boost::distance(m_data)));
    }

    template <typename OtherContainer>
    basic_document(const basic_document<OtherContainer>& other,
                   std::enable_if_t<std::is_constructible<container_type, OtherContainer>::value>* =
                       nullptr) noexcept(std::is_nothrow_constructible<container_type, OtherContainer>::value)
        : m_data(other.m_data) {}

    template <typename OtherContainer>
    basic_document(const basic_document<OtherContainer>& other,
                   std::enable_if_t<!std::is_constructible<container_type, OtherContainer>::value &&
                                    detail::container_has_push_back<container_type>::value &&
                                    std::is_constructible<container_type, typename OtherContainer::const_iterator,
                                                          typename OtherContainer::const_iterator>::value>* = nullptr)
        : m_data(other.m_data.begin(), other.m_data.end()) {}

    template <size_t N> explicit basic_document(std::array<char, N>, std::enable_if_t<(N < 5)>* = nullptr) = delete;

    template <typename ForwardRange>
    explicit basic_document(
        ForwardRange&& rng, std::enable_if_t<detail::is_range_of_same_value<ForwardRange, char>::value>* = nullptr,
        std::enable_if_t<
            std::conditional_t<detail::is_iterator_range<container_type>::value,
                               detail::is_range_of_iterator<
                                   ForwardRange, boost::mpl::bind<detail::quote<std::is_constructible>,
                                                                  typename container_type::iterator, boost::mpl::_1>>,
                               std::true_type>::value>* = nullptr,
        std::enable_if_t<!std::is_same<container_type, std::decay_t<ForwardRange>>::value &&
                         detail::is_range_of_iterator<
                             ForwardRange, boost::mpl::bind<detail::quote<std::is_constructible>, container_type,
                                                            boost::mpl::_1, boost::mpl::_1>>::value>* = nullptr)
        : basic_document(container_type(std::begin(rng), std::end(rng))) {}

    template <typename ForwardRange>
    explicit basic_document(
        ForwardRange&& rng,
        std::enable_if_t<
            boost::mpl::and_<detail::is_range_of_value<ForwardRange, boost::mpl::quote1<detail::is_element>>,
                             detail::container_has_push_back<container_type>,
                             boost::mpl::not_<detail::is_document<std::decay_t<ForwardRange>>>>::type::value>* =
            nullptr) {
        static_assert(!detail::is_document<std::decay_t<ForwardRange>>::value, "");
        std::array<char, 4> arr{{0, 0, 0, 0}};
        boost::range::push_back(m_data, arr);
        for(auto&& e : rng) {
            e.write_to_container(m_data, m_data.end());
        }
        m_data.push_back('\0');
        auto size = jbson::detail::native_to_little_endian(static_cast<int32_t>(m_data.size()));
        static_assert(4 == size.size(), "");

        boost::range::copy(size, m_data.begin());
    }

    template <typename ForwardIterator>
    basic_document(ForwardIterator first, ForwardIterator last,
                   std::enable_if_t<
                       std::is_constructible<basic_document, boost::iterator_range<ForwardIterator>>::value>* = nullptr)
        : basic_document(boost::make_iterator_range(first, last)) {}

    const_iterator begin() const {
        if(boost::distance(m_data) <= static_cast<ptrdiff_t>(sizeof(int32_t)))
            BOOST_THROW_EXCEPTION(invalid_document_size{});
        return {std::next(m_data.begin(), sizeof(int32_t)), std::prev(m_data.end())};
    }

    const_iterator end() const noexcept {
        auto last = std::prev(m_data.end());
        return {last, last};
    }

    const_iterator find(boost::string_ref elem_name) const {
        return std::find_if(begin(), end(), [&elem_name](auto&& elem) { return elem.name() == elem_name; });
    }

    const_iterator erase(const const_iterator& it) {
        assert(it != end());
        auto pos = m_data.erase(it.m_start, std::next(it.m_start, it.m_cur->size()));

        auto size = jbson::detail::native_to_little_endian(static_cast<int32_t>(m_data.size()));
        static_assert(4 == size.size(), "");

        boost::range::copy(size, m_data.begin());

        return {pos, std::prev(m_data.end())};
    }

    template <typename EContainer>
    const_iterator insert(const const_iterator& it, const basic_element<EContainer>& el) {
        container_type data;
        el.write_to_container(data, data.end());

        auto pos = m_data.insert(it.m_start, data.begin(), data.end());

        auto size = jbson::detail::native_to_little_endian(static_cast<int32_t>(m_data.size()));
        static_assert(4 == size.size(), "");

        boost::range::copy(size, m_data.begin());

        return {pos, std::prev(m_data.end())};
    }

    template <typename... Args> const_iterator emplace(const const_iterator& it, Args&&... args) {
        container_type data;
        basic_element<container_type>::write_to_container(data, data.end(), std::forward<Args>(args)...);

        auto pos = m_data.insert(it.m_start, data.begin(), data.end());

        auto size = jbson::detail::native_to_little_endian(static_cast<int32_t>(m_data.size()));
        static_assert(4 == size.size(), "");

        boost::range::copy(size, m_data.begin());

        return {pos, std::prev(m_data.end())};
    }

    int32_t size() const noexcept { return boost::distance(m_data); }

    const container_type& data() const& noexcept { return m_data; }

    container_type data() const&& noexcept(std::is_nothrow_copy_constructible<container_type>::value) { return m_data; }

    container_type&& data() && noexcept(std::is_nothrow_move_constructible<container_type>::value) {
        return std::move(m_data);
    }

    bool valid(const validity_level lvl = validity_level::bson_size, const bool recurse = true) const {
        bool ret{true};

        if(ret && lvl >= validity_level::data_size)
            ret = static_cast<ptrdiff_t>(boost::distance(m_data)) > static_cast<ptrdiff_t>(sizeof(int32_t));
        if(ret && lvl >= validity_level::bson_size) {
            ret = static_cast<ptrdiff_t>(boost::distance(m_data)) ==
                  detail::little_endian_to_native<int32_t>(m_data.begin(), m_data.end());
        }
        if(ret && lvl >= validity_level::element_construct) {
            try {
                for(auto&& e : *this) {
                    if(recurse && e.type() == jbson::element_type::document_element)
                        ret = get<jbson::element_type::document_element>(e).valid(lvl, recurse);
                    else if(recurse && e.type() == jbson::element_type::array_element)
                        ret = get<jbson::element_type::array_element>(e).valid(lvl, recurse);
                    else if(recurse && e.type() == jbson::element_type::scoped_javascript_element) {
                        decltype(get<jbson::element_type::document_element>(e)) scope;
                        std::tie(std::ignore, scope) = get<jbson::element_type::scoped_javascript_element>(e);
                        ret = scope.valid(lvl, recurse);
                    }
                    if(!ret)
                        break;

                    if((lvl & validity_level::unicode_valid) == validity_level::unicode_valid &&
                       e.type() == jbson::element_type::string_element) {
                        std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> u8to32{};
                        auto str = get<jbson::element_type::string_element>(e);
                        u8to32.from_bytes(str.data(), str.data() + str.size());
                    }
                    if(!ret)
                        break;
                }
            }
            catch(...) {
                ret = false;
            }
        }
        return ret;
    }

    template <typename EContainer> explicit operator basic_document_set<EContainer>() const {
        auto set = basic_document_set<EContainer>{};
        for(auto&& e : *this) {
            set.emplace(e);
        }
        return std::move(set);
    }

    template <typename C, typename EC> bool operator==(const basic_document<C, EC>& other) const {
        return boost::equal(m_data, other.m_data);
    }

    void swap(basic_document& other) noexcept {
        using std::swap;
        swap(m_data, other.m_data);
    }

  private:
    container_type m_data;
    template <typename, typename> friend class basic_document;
    template <typename, typename> friend class basic_array;
};

template <class Container, class ElementContainer> class basic_array : basic_document<Container, ElementContainer> {
    using base = basic_document<Container, ElementContainer>;
    template <typename, typename> friend class basic_array;

  public:
    using typename base::container_type;
    using typename base::element_type;
    using typename base::iterator;
    using typename base::const_iterator;
    using typename base::value_type;

    using base::m_data;
    using base::begin;
    using base::end;
    using base::data;
    using base::size;
    using base::swap;

    basic_array() : base() {}

    template <typename OtherContainer>
    basic_array(const basic_array<OtherContainer>& other,
                std::enable_if_t<std::is_constructible<container_type, OtherContainer>::value>* =
                    nullptr) noexcept(std::is_nothrow_constructible<container_type, OtherContainer>::value)
        : base(other.m_data) {}

    template <typename Arg>
    explicit basic_array(
        Arg&& arg,
        std::enable_if_t<std::is_constructible<base, Arg&&>::value && !std::is_convertible<Arg&&, base>::value>* =
            nullptr) noexcept(std::is_nothrow_constructible<base, Arg&&>::value)
        : base(std::forward<Arg>(arg)) {}

    template <typename Arg1, typename Arg2>
    basic_array(Arg1&& arg1, Arg2&& arg2,
                std::enable_if_t<std::is_constructible<base, Arg1&&, Arg2&&>::value>* =
                    nullptr) noexcept(std::is_nothrow_constructible<base, Arg1&&, Arg2&&>::value)
        : base(std::forward<Arg1>(arg1), std::forward<Arg2>(arg2)) {}

    const_iterator find(int32_t idx) const { return base::find(std::to_string(idx)); }

    bool valid(const validity_level lvl = validity_level::bson_size, const bool recurse = true) const {
        bool ret = base::valid(lvl, recurse);
        if(ret && (lvl & validity_level::array_indices) == validity_level::array_indices) {
            try {
                int32_t count{0};
                for(auto&& e : *this) {
                    if(!(ret = (e.name() == std::to_string(count))))
                        break;

                    ++count;
                }
            }
            catch(...) {
                ret = false;
            }
        }
        return ret;
    }

    template <typename SequenceContainer,
              typename = std::enable_if_t<detail::container_has_push_back<SequenceContainer>::value>,
              typename = std::enable_if_t<
                  detail::is_range_of_value<SequenceContainer, boost::mpl::quote1<detail::is_element>>::value>>
    explicit operator SequenceContainer() const {
        auto fun = [](auto&& a, auto&& b) {
#ifdef _GNU_SOURCE
            // natural sort
            return strverscmp(a.name().data(), b.name().data());
#else
            return a.name().compare(b.name());
#endif
        };
        auto vec = SequenceContainer{};
        for(auto&& e : *this)
            vec.push_back(e);
        boost::range::sort(vec, [fun](auto&& e1, auto&& e2) { return fun(e1, e2) < 0; });
        assert(std::unique(vec.begin(), vec.end(), [fun](auto&& e1, auto&& e2) { return fun(e1, e2) == 0; }) ==
               vec.end());
        return std::move(vec);
    }
};

template <typename Container, typename EContainer>
void swap(basic_document<Container, EContainer>& a,
          basic_document<Container, EContainer>& b) noexcept(noexcept(a.swap(b))) {
    std::abort();
    a.swap(b);
}

template <typename Container, typename EContainer>
void swap(basic_array<Container, EContainer>& a, basic_array<Container, EContainer>& b) noexcept(noexcept(a.swap(b))) {
    std::abort();
    a.swap(b);
}

// document_set
template <typename Container, typename SetContainer>
void value_set(basic_element<Container>& c, const basic_document_set<SetContainer>& val) {
    c.value(document(val));
}

} // namespace jbson

#endif // JBSON_DOCUMENT_HPP