unicode_bidi.hpp

// Copyright Take Vos 2020-2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
 
#pragma once
 
#include "unicode_bidi_class.hpp"
#include "unicode_description.hpp"
 
namespace tt {
namespace detail {
 
struct unicode_bidi_char_info {
    size_t index;
 
    char32_t code_point;
 
    int8_t embedding_level;
 
    unicode_bidi_class direction;
 
    unicode_bidi_class bidi_class;
 
    unicode_description const *description;
 
    [[nodiscard]] unicode_bidi_char_info(size_t index, char32_t code_point) noexcept :
        index(index), code_point(code_point), embedding_level(0)
    {
        description = &unicode_description_find(code_point);
        bidi_class = description->bidi_class();
        direction = bidi_class;
    }
 
    [[nodiscard]] unicode_bidi_char_info(size_t index, unicode_bidi_class bidi_class) noexcept :
        index(index),
        code_point(U'\ufffd'),
        direction(bidi_class),
        bidi_class(bidi_class),
        embedding_level(0),
        description(nullptr)
    {
    }
};
 
using unicode_bidi_char_info_vector = std::vector<unicode_bidi_char_info>;
using unicode_bidi_char_info_iterator = unicode_bidi_char_info_vector::iterator;
using unicode_bidi_char_info_const_iterator = unicode_bidi_char_info_vector::const_iterator;
 
struct unicode_bidi_paragraph {
    using characters_type = std::vector<unicode_bidi_char_info>;
 
    characters_type characters;
 
    template<typename... Args>
    void emplace_character(Args &&...args) noexcept
    {
        characters.emplace_back(std::forward<Args>(args)...);
    }
};
 
template<typename OutputIt, typename SetCodePoint>
static void unicode_bidi_L4(
    unicode_bidi_char_info_iterator first,
    unicode_bidi_char_info_iterator last,
    OutputIt output_it,
    SetCodePoint set_code_point) noexcept
{
    for (auto it = first; it != last; ++it, ++output_it) {
        if (it->direction == unicode_bidi_class::R && it->description->bidi_bracket_type() != unicode_bidi_bracket_type::n) {
            set_code_point(*output_it, it->description->bidi_mirrored_glyph());
        }
    }
}
 
struct unicode_bidi_test_parameters {
    unicode_bidi_class force_paragraph_direction = unicode_bidi_class::unknown;
    bool enable_mirrored_brackets = true;
    bool enable_line_separator = true;
};
 
[[nodiscard]] unicode_bidi_char_info_iterator unicode_bidi_P1(
    unicode_bidi_char_info_iterator first,
    unicode_bidi_char_info_iterator last,
    unicode_bidi_test_parameters test_parameters = {}) noexcept;
 
} // namespace detail
 
template<typename It, typename GetCodePoint, typename SetCodePoint>
It unicode_bidi(
    It first,
    It last,
    GetCodePoint get_code_point,
    SetCodePoint set_code_point,
    detail::unicode_bidi_test_parameters test_parameters = {})
{
    auto proxy = detail::unicode_bidi_char_info_vector{};
    proxy.reserve(std::distance(first, last));
 
    size_t index = 0;
    for (auto it = first; it != last; ++it) {
        proxy.emplace_back(index++, get_code_point(*it));
    }
 
    auto proxy_last = detail::unicode_bidi_P1(std::begin(proxy), std::end(proxy), test_parameters);
    last = shuffle_by_index(first, last, std::begin(proxy), proxy_last, [](ttlet &item) {
        return item.index;
    });
 
    detail::unicode_bidi_L4(std::begin(proxy), proxy_last, first, set_code_point);
    return last;
}
 
} // namespace tt