blob: 09f269df0ff9fd789fa8bb529dfdd22ea5feb277 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
/*
* Copyright (c) 2021, Tim Flynn <trflynn89@pm.me>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Forward.h>
#include <AK/Optional.h>
#include <AK/Span.h>
#include <AK/String.h>
#include <AK/Types.h>
#include <AK/Vector.h>
namespace AK {
Vector<u16> utf8_to_utf16(StringView const&);
Vector<u16> utf8_to_utf16(Utf8View const&);
class Utf16View;
class Utf16CodePointIterator {
friend class Utf16View;
public:
Utf16CodePointIterator() = default;
~Utf16CodePointIterator() = default;
bool operator==(Utf16CodePointIterator const& other) const
{
return (m_ptr == other.m_ptr) && (m_remaining_code_units == other.m_remaining_code_units);
}
bool operator!=(Utf16CodePointIterator const& other) const
{
return !(*this == other);
}
Utf16CodePointIterator& operator++();
u32 operator*() const;
size_t length_in_code_units() const;
private:
Utf16CodePointIterator(u16 const* ptr, size_t length)
: m_ptr(ptr)
, m_remaining_code_units(length)
{
}
u16 const* m_ptr { nullptr };
size_t m_remaining_code_units { 0 };
};
class Utf16View {
public:
static bool is_high_surrogate(u16);
static bool is_low_surrogate(u16);
static u32 decode_surrogate_pair(u16 high_surrogate, u16 low_surrogate);
Utf16View() = default;
~Utf16View() = default;
explicit Utf16View(Span<u16 const> code_units)
: m_code_units(code_units)
{
}
Utf16View& operator=(Utf16View const&) = default;
Utf16View& operator=(Utf16View&&) = default;
bool operator==(Utf16View const& other) const;
enum class AllowInvalidCodeUnits {
Yes,
No,
};
String to_utf8(AllowInvalidCodeUnits = AllowInvalidCodeUnits::No) const;
bool is_empty() const { return m_code_units.is_empty(); }
size_t length_in_code_units() const { return m_code_units.size(); }
size_t length_in_code_points() const;
Utf16CodePointIterator begin() const { return { begin_ptr(), m_code_units.size() }; }
Utf16CodePointIterator end() const { return { end_ptr(), 0 }; }
u16 const* data() const { return m_code_units.data(); }
u16 code_unit_at(size_t index) const;
Utf16View substring_view(size_t code_unit_offset, size_t code_unit_length) const;
Utf16View substring_view(size_t code_unit_offset) const { return substring_view(code_unit_offset, length_in_code_units() - code_unit_offset); }
bool validate(size_t& valid_code_units) const;
bool validate() const
{
size_t valid_code_units;
return validate(valid_code_units);
}
private:
u16 const* begin_ptr() const { return m_code_units.data(); }
u16 const* end_ptr() const { return begin_ptr() + m_code_units.size(); }
size_t calculate_length_in_code_points() const;
Span<u16 const> m_code_units;
mutable Optional<size_t> m_length_in_code_points;
};
}
using AK::Utf16View;
|
